From 47de3688489b1c3abc3f791deb6237201ec35c42 Mon Sep 17 00:00:00 2001 From: Mateusz Dalke <150788324+dalkedev@users.noreply.github.com> Date: Fri, 6 Nov 2026 20:49:10 +0000 Subject: [PATCH 1/8] test: measure synthetic archive write responsiveness Add bounded test-only save timing and real loopback HTTP/TLS evidence checks, independent timer/network probes and positive controls. Include manually dispatched Linux/Windows diagnostics and a persistence-preserving bounded-writer proposal for #28. No production scheduling or durability change. --- .github/workflows/checks.yml | 45 ++- crates/scope-core/src/diagnostics.rs | 166 ++++++++ crates/scope-core/src/diagnostics/probes.rs | 362 +++++++++++++++++ crates/scope-core/src/diagnostics/tests.rs | 86 ++++ crates/scope-core/src/diagnostics/workload.rs | 241 ++++++++++++ crates/scope-core/src/lib.rs | 28 +- docs/ARCHIVE_RESPONSIVENESS.md | 157 ++++++++ docs/VERIFICATION.md | 3 + .../plans/2026-11-06-archive-measurement.md | 45 +++ .../2026-11-06-archive-measurement-design.md | 53 +++ scripts/measure-archive.py | 368 ++++++++++++++++++ scripts/tests/test_measure_archive.py | 166 ++++++++ 12 files changed, 1718 insertions(+), 2 deletions(-) create mode 100644 crates/scope-core/src/diagnostics.rs create mode 100644 crates/scope-core/src/diagnostics/probes.rs create mode 100644 crates/scope-core/src/diagnostics/tests.rs create mode 100644 crates/scope-core/src/diagnostics/workload.rs create mode 100644 docs/ARCHIVE_RESPONSIVENESS.md create mode 100644 docs/superpowers/plans/2026-11-06-archive-measurement.md create mode 100644 docs/superpowers/specs/2026-11-06-archive-measurement-design.md create mode 100644 scripts/measure-archive.py create mode 100644 scripts/tests/test_measure_archive.py diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.yml index 41ff35d..cb96776 100644 --- a/.github/workflows/checks.yml +++ b/.github/workflows/checks.yml @@ -3,13 +3,22 @@ on: push: branches: [main, 'release/**'] pull_request: + workflow_dispatch: + inputs: + diagnostic: + description: Synthetic diagnostic to run (no release or deployment) + type: choice + options: [archive-measurement] + required: true + default: archive-measurement permissions: contents: read concurrency: - group: checks-${{ github.ref }} + group: checks-${{ github.event_name }}-${{ github.ref }} cancel-in-progress: true jobs: desktop: + if: github.event_name != 'workflow_dispatch' name: Check ${{ matrix.os }} timeout-minutes: 60 strategy: @@ -68,3 +77,37 @@ jobs: target/release/scope-mcp* if-no-files-found: error retention-days: 14 + + archive-measurement: + name: Archive measurement ${{ matrix.os }} + if: github.event_name == 'workflow_dispatch' && inputs.diagnostic == 'archive-measurement' + runs-on: ${{ matrix.os }} + timeout-minutes: 45 + strategy: + fail-fast: false + matrix: + os: [ubuntu-22.04, windows-2022] + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + - uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 + with: + python-version: '3.12' + - uses: dtolnay/rust-toolchain@b725eda525362e7cf34af9a7243cac1e3f01a7ec + with: + toolchain: 1.99.1 + - name: Runner regressions + run: python -m unittest discover -s scripts/tests -p test_measure_archive.py + - name: Evidence detector regressions + run: cargo test --locked -p scope-core --lib diagnostics:: + - name: Measure fresh synthetic archives (debug and release separately) + run: python scripts/measure-archive.py --profiles debug release --samples 3 --workers 0 2 --output-dir .runtime/archive-measurement + - name: Upload numeric synthetic diagnostics only + if: always() + uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 + with: + name: archive-measurement-${{ matrix.os }}-${{ github.sha }} + path: .runtime/archive-measurement/measurement.json + if-no-files-found: error + retention-days: 14 diff --git a/crates/scope-core/src/diagnostics.rs b/crates/scope-core/src/diagnostics.rs new file mode 100644 index 0000000..36a4d45 --- /dev/null +++ b/crates/scope-core/src/diagnostics.rs @@ -0,0 +1,166 @@ +//! Compiled only in the core unit-test binary, never in shipping applications. +use super::*; +use std::collections::BTreeSet; +use std::time::{Duration, Instant}; + +mod tests; + +const CLIENTS: usize = 32; +const SAVE_CAP: usize = 256; + +#[derive(Default, Serialize)] +struct SaveSample { + serialization_ns: u64, + mutex_wait_ns: u64, + statement_ns: u64, + serialized_bytes: usize, + success: bool, +} +#[derive(Default, Serialize)] +pub(super) struct SaveSamples { + samples: Vec, + dropped: usize, +} +#[derive(Default)] +pub(super) struct SaveMetrics { + enabled: AtomicBool, + values: Mutex, +} +impl SaveMetrics { + pub(super) fn start(&self) -> Option { + self.enabled.load(Ordering::Relaxed).then(Instant::now) + } + pub(super) fn record( + &self, + start: Option, + serialized: Instant, + acquired: Instant, + finished: Instant, + bytes: usize, + success: bool, + ) { + if let Some(start) = start { + self.push(SaveSample { + serialization_ns: ns(serialized.duration_since(start)), + mutex_wait_ns: ns(acquired.duration_since(serialized)), + statement_ns: ns(finished.duration_since(acquired)), + serialized_bytes: bytes, + success, + }); + } + } + fn push(&self, sample: SaveSample) { + // This lock is outside the DB guard; the harness reads only after the batch. + let mut values = self.values.lock().unwrap(); + if values.samples.len() < SAVE_CAP { + values.samples.push(sample); + } else { + values.dropped += 1; + } + } + fn take(&self) -> SaveSamples { + std::mem::take(&mut *self.values.lock().unwrap()) + } +} +fn ns(duration: Duration) -> u64 { + duration.as_nanos().min(u64::MAX as u128) as u64 +} + +fn valid_evidence(rows: &[Exchange], session: &str, rules: &[String; 3]) -> bool { + let mut ids = BTreeSet::new(); + let mut indexes = BTreeSet::new(); + rows.len() == CLIENTS + && rows.iter().all(|e| { + let index = url::Url::parse(&e.url).ok().and_then(|url| { + let values: Vec<_> = url + .query_pairs() + .filter(|(key, _)| key == "i") + .map(|(_, v)| v.into_owned()) + .collect(); + (values.len() == 1) + .then(|| values[0].parse::().ok()) + .flatten() + }); + let expected = [ + ("rewriteRequest", "request"), + ("mockResponse", "request"), + ("rewriteResponse", "response"), + ]; + ids.insert(&e.id) + && index.is_some_and(|i| i < CLIENTS && indexes.insert(i)) + && e.session_id == session + && e.method == "GET" + && e.completed + && e.error.is_none() + && e.status == Some(201) + && e.provenance == TrafficProvenance::Mock + && e.request_body == "request rule" + && !e.request_body_base64 + && e.response_body == "response rule" + && !e.response_body_base64 + && e.request_headers.iter().any(|h| { + h.name.eq_ignore_ascii_case("x-measure-index") + && h.value.parse::().ok() == index + }) + && e.original_request.as_ref().is_some_and(|v| { + v["body"] == "" + && v["method"] == "GET" + && v["url"] == e.url + && v["headers"].as_array().is_some_and(|headers| { + headers.iter().any(|h| { + h["name"] == "x-measure-index" + && h["value"].as_str().and_then(|s| s.parse::().ok()) + == index + }) + }) + }) + && e.original_response + .as_ref() + .is_some_and(|v| v["body"] == "mock body" && v["status"] == 201) + && e.applied_rules.len() == 3 + && e.applied_rules.iter().enumerate().all(|(n, r)| { + r.rule_id == rules[n] + && r.name == format!("Rule {}", n + 1) + && r.action == expected[n].0 + && r.stage == expected[n].1 + }) + }) +} + +mod probes; +mod workload; + +// Explicitly ignored: manually launched by scripts/measure-archive.py, never a CI timing gate. +#[test] +#[ignore = "opt-in bounded synthetic measurement"] +fn archive_responsiveness() { + let workers: usize = std::env::var("SCOPE_MEASURE_WORKERS") + .unwrap() + .parse() + .unwrap(); + assert!(workers == 0 || workers == 2, "unsupported runtime"); + let samples: usize = std::env::var("SCOPE_MEASURE_SAMPLES") + .unwrap() + .parse() + .unwrap(); + assert!((1..=5).contains(&samples), "unsupported sample count"); + let mut builder = if workers == 0 { + tokio::runtime::Builder::new_current_thread() + } else { + let mut b = tokio::runtime::Builder::new_multi_thread(); + b.worker_threads(workers); + b + }; + let runtime = builder + .enable_all() + .max_blocking_threads(2) + .build() + .unwrap(); + let report = runtime.block_on(workload::run(samples, workers)); + let output = std::env::var_os("SCOPE_MEASURE_OUTPUT").expect("output required"); + std::fs::write(output, serde_json::to_vec_pretty(&report).unwrap()).unwrap(); + assert_eq!( + report["status"], "PASS", + "synthetic measurement/evidence/control failure; inspect numeric report" + ); +} diff --git a/crates/scope-core/src/diagnostics/probes.rs b/crates/scope-core/src/diagnostics/probes.rs new file mode 100644 index 0000000..17b808f --- /dev/null +++ b/crates/scope-core/src/diagnostics/probes.rs @@ -0,0 +1,362 @@ +use super::*; +use std::io::{Read, Write}; +use std::net::{SocketAddr, TcpStream}; +use tokio::io::{AsyncReadExt, AsyncWriteExt}; + +const PROBE_CAP: usize = 8192; +const PERIOD: Duration = Duration::from_millis(10); + +#[derive(Serialize)] +struct ProbeSample { + // Timer deadlines are scheduled; network attempts have no fixed cadence. + scheduled_ns: Option, + start_ns: u64, + end_ns: u64, + elapsed_ns: u64, + success: bool, + in_window: bool, +} +#[derive(Serialize)] +struct ProbeValues { + elapsed_ns: Vec, + samples: Vec, + failures: usize, + dropped: usize, + missed_periods: u64, + in_window_samples: usize, + window_status: &'static str, +} +impl Default for ProbeValues { + fn default() -> Self { + Self { + elapsed_ns: Vec::new(), + samples: Vec::new(), + failures: 0, + dropped: 0, + missed_periods: 0, + in_window_samples: 0, + window_status: "NOTRUN", + } + } +} +impl ProbeValues { + fn push(&mut self, sample: ProbeSample) { + self.failures += usize::from(!sample.success); + if self.samples.len() < PROBE_CAP { + if sample.success { + self.elapsed_ns.push(sample.elapsed_ns); + } + self.samples.push(sample); + } else { + self.dropped += 1; + } + } + fn mark_window(&mut self, start: u64, end: u64) { + for sample in &mut self.samples { + sample.in_window = end > start + && match sample.scheduled_ns { + // A delayed wake still measures the deadline inside the batch. + Some(scheduled) => start <= scheduled && scheduled < end, + // Include attempts started before the batch if service spans it. + None => sample.start_ns < end && sample.end_ns > start, + }; + } + self.in_window_samples = self.samples.iter().filter(|s| s.in_window).count(); + self.window_status = if self.dropped > 0 { + "INVALID" + } else if self.in_window_samples == 0 { + "NOTRUN" + } else { + "PASS" + }; + } +} + +pub(super) struct Probes { + epoch: Instant, + stop: Arc, + active: Arc, + timer: tokio::task::JoinHandle, + server: tokio::task::JoinHandle<()>, + network: std::thread::JoinHandle, +} +#[derive(Serialize)] +pub(super) struct ProbeReport { + timer: ProbeValues, + network: ProbeValues, + period_ms: u64, + cap_per_probe: usize, + window_start_ns: u64, + window_end_ns: u64, +} +impl ProbeReport { + pub(super) fn detects_control(&self) -> bool { + // Only in-window observations validate the intentional blocking control. + self.timer + .samples + .iter() + .any(|s| s.in_window && s.elapsed_ns > 100_000_000) + && self + .network + .samples + .iter() + .any(|s| s.in_window && (!s.success || s.elapsed_ns > 100_000_000)) + && self.covered() + } + pub(super) fn covered(&self) -> bool { + // Collector validity differs from coverage of a potentially sub-period batch. + self.timer.dropped == 0 && self.network.dropped == 0 + } +} +impl Probes { + pub(super) async fn start() -> Self { + let epoch = Instant::now(); + let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); + let addr = listener.local_addr().unwrap(); + let stop = Arc::new(AtomicBool::new(false)); + let active = Arc::new(AtomicBool::new(false)); + let server = tokio::spawn(async move { + loop { + let Ok((mut stream, _)) = listener.accept().await else { + break; + }; + let mut byte = [0u8; 1]; + // One finite probe at a time; no detached connection tasks. + if matches!( + tokio::time::timeout(Duration::from_secs(2), stream.read_exact(&mut byte)) + .await, + Ok(Ok(_)) + ) { + let _ = stream.write_all(&byte).await; + } + } + }); + let ready = Arc::new(AtomicBool::new(false)); + let (thread_stop, thread_active, thread_ready) = + (stop.clone(), active.clone(), ready.clone()); + let network = std::thread::spawn(move || { + let mut values = ProbeValues::default(); + while !thread_stop.load(Ordering::SeqCst) { + let started = Instant::now(); + let result = echo(addr); + let ended = Instant::now(); + if result.is_ok() { + thread_ready.store(true, Ordering::SeqCst); + } + if thread_active.load(Ordering::SeqCst) { + values.push(ProbeSample { + scheduled_ns: None, + start_ns: ns(started.duration_since(epoch)), + end_ns: ns(ended.duration_since(epoch)), + elapsed_ns: ns(ended.duration_since(started)), + success: result.is_ok(), + in_window: false, + }); + } + std::thread::sleep(PERIOD); + } + values + }); + let (timer_stop, timer_active) = (stop.clone(), active.clone()); + let (tx, rx) = tokio::sync::oneshot::channel(); + let timer = tokio::spawn(async move { + let mut values = ProbeValues::default(); + let mut deadline = tokio::time::Instant::now() + PERIOD; + let _ = tx.send(()); + loop { + tokio::time::sleep_until(deadline).await; + let now = tokio::time::Instant::now(); + let lag = now.saturating_duration_since(deadline); + let skipped = (lag.as_nanos() / PERIOD.as_nanos()) as u64; + if timer_active.load(Ordering::SeqCst) { + let wake_ns = ns(now.into_std().duration_since(epoch)); + values.push(ProbeSample { + scheduled_ns: Some(ns(deadline.into_std().duration_since(epoch))), + start_ns: wake_ns, + end_ns: wake_ns, + elapsed_ns: ns(lag), + success: true, + in_window: false, + }); + values.missed_periods += skipped; + } + deadline += PERIOD * (skipped as u32 + 1); + if timer_stop.load(Ordering::SeqCst) { + break; + } + } + values + }); + rx.await.unwrap(); + tokio::time::timeout(Duration::from_secs(3), async { + while !ready.load(Ordering::SeqCst) { + tokio::time::sleep(Duration::from_millis(1)).await; + } + }) + .await + .expect("loopback probe readiness failed"); + active.store(true, Ordering::SeqCst); + Self { + epoch, + stop, + active, + timer, + server, + network, + } + } + pub(super) async fn finish(self, batch_start: Instant, batch_end: Instant) -> ProbeReport { + // Drain delayed observations; these remain distinguishable from the batch. + tokio::time::sleep(PERIOD * 2).await; + self.stop.store(true, Ordering::SeqCst); + let mut network = tokio::task::spawn_blocking(move || self.network.join().unwrap()) + .await + .unwrap(); + let mut timer = self.timer.await.unwrap(); + self.active.store(false, Ordering::SeqCst); + self.server.abort(); + let _ = self.server.await; + let window_start_ns = ns(batch_start.duration_since(self.epoch)); + let window_end_ns = ns(batch_end.duration_since(self.epoch)); + timer.mark_window(window_start_ns, window_end_ns); + network.mark_window(window_start_ns, window_end_ns); + ProbeReport { + timer, + network, + period_ms: 10, + cap_per_probe: PROBE_CAP, + window_start_ns, + window_end_ns, + } + } +} +fn echo(addr: SocketAddr) -> std::io::Result<()> { + let mut socket = TcpStream::connect_timeout(&addr, Duration::from_secs(2))?; + socket.set_read_timeout(Some(Duration::from_secs(2)))?; + socket.set_write_timeout(Some(Duration::from_secs(2)))?; + socket.write_all(&[42])?; + let mut byte = [0]; + socket.read_exact(&mut byte)?; + if byte != [42] { + return Err(std::io::Error::other("invalid synthetic echo")); + } + Ok(()) +} + +#[test] +fn empty_probe_collectors_do_not_fabricate_window_coverage() { + let report = ProbeReport { + timer: ProbeValues::default(), + network: ProbeValues::default(), + period_ms: 10, + cap_per_probe: PROBE_CAP, + window_start_ns: 100, + window_end_ns: 101, + }; + assert!( + report.covered(), + "empty bounded collectors are valid; window coverage is separate" + ); + let json = serde_json::to_value(report).unwrap(); + assert_eq!(json["timer"]["window_status"], "NOTRUN"); + assert_eq!(json["network"]["window_status"], "NOTRUN"); +} + +#[test] +fn window_coverage_keeps_delayed_deadlines_and_intersecting_network_attempts() { + let mut timer = ProbeValues::default(); + timer.push(ProbeSample { + scheduled_ns: Some(150), + start_ns: 300, + end_ns: 300, + elapsed_ns: 150, + success: true, + in_window: false, + }); + timer.push(ProbeSample { + scheduled_ns: Some(250), + start_ns: 260, + end_ns: 260, + elapsed_ns: 10, + success: true, + in_window: false, + }); + timer.mark_window(100, 200); + assert_eq!(timer.in_window_samples, 1); + assert!(timer.samples[0].in_window); + assert!(!timer.samples[1].in_window); + let mut network = ProbeValues::default(); + for (start_ns, end_ns) in [(50, 150), (150, 250), (200, 210), (10, 100)] { + network.push(ProbeSample { + scheduled_ns: None, + start_ns, + end_ns, + elapsed_ns: end_ns - start_ns, + success: true, + in_window: false, + }); + } + network.mark_window(100, 200); + assert_eq!(network.in_window_samples, 2); + assert_eq!(network.window_status, "PASS"); + network.mark_window(300, 400); + assert_eq!(network.in_window_samples, 0); + assert_eq!(network.window_status, "NOTRUN"); +} + +#[test] +fn control_detector_rejects_lag_outside_its_window() { + let mut timer = ProbeValues::default(); + let mut network = ProbeValues::default(); + timer.push(ProbeSample { + scheduled_ns: Some(250_000_000), + start_ns: 500_000_000, + end_ns: 500_000_000, + elapsed_ns: 250_000_000, + success: true, + in_window: false, + }); + network.push(ProbeSample { + scheduled_ns: None, + start_ns: 250_000_000, + end_ns: 500_000_000, + elapsed_ns: 250_000_000, + success: true, + in_window: false, + }); + timer.mark_window(0, 200_000_000); + network.mark_window(0, 200_000_000); + let mut report = ProbeReport { + timer, + network, + period_ms: 10, + cap_per_probe: PROBE_CAP, + window_start_ns: 0, + window_end_ns: 200_000_000, + }; + assert!(!report.detects_control()); + report.timer.mark_window(200_000_000, 400_000_000); + report.network.mark_window(200_000_000, 400_000_000); + assert!(report.detects_control()); +} + +#[test] +fn draining_real_probes_does_not_turn_an_empty_window_into_coverage() { + let runtime = tokio::runtime::Builder::new_current_thread() + .enable_all() + .build() + .unwrap(); + runtime.block_on(async { + let probes = Probes::start().await; + let boundary = Instant::now(); + let report = probes.finish(boundary, boundary).await; + assert!(report.covered()); + assert!(!report.timer.samples.is_empty()); + assert!(!report.network.samples.is_empty()); + assert_eq!(report.timer.in_window_samples, 0); + assert_eq!(report.network.in_window_samples, 0); + assert_eq!(report.timer.window_status, "NOTRUN"); + assert_eq!(report.network.window_status, "NOTRUN"); + assert!(!report.detects_control()); + }); +} diff --git a/crates/scope-core/src/diagnostics/tests.rs b/crates/scope-core/src/diagnostics/tests.rs new file mode 100644 index 0000000..f281334 --- /dev/null +++ b/crates/scope-core/src/diagnostics/tests.rs @@ -0,0 +1,86 @@ +use super::*; + +// Catches silently accepting missing/reordered rule evidence or wrong request pairing. +#[test] +fn evidence_detector_rejects_corrupted_archive_rows() { + let rules = ["a".to_string(), "b".to_string(), "c".to_string()]; + let session = "synthetic"; + let dir = tempfile::tempdir().unwrap(); + let engine = Engine::open(dir.path()).unwrap(); + let mut rows = Vec::new(); + for i in 0..32 { + let mut e = engine.fresh_exchange( + session, + "GET".into(), + format!("http://localhost:1/pause?i={i}"), + ); + e.completed = true; + e.provenance = TrafficProvenance::Mock; + e.status = Some(201); + e.request_headers.push(Header { + name: "x-measure-index".into(), + value: i.to_string(), + }); + e.request_body = "request rule".into(); + e.response_body = "response rule".into(); + e.original_request = Some( + serde_json::json!({"body":"", "method":"GET", "url":e.url, "headers":[{"name":"x-measure-index","value":i.to_string()}]}), + ); + e.original_response = Some(serde_json::json!({"status":201,"body":"mock body"})); + for (n, (action, stage)) in [ + ("rewriteRequest", "request"), + ("mockResponse", "request"), + ("rewriteResponse", "response"), + ] + .iter() + .enumerate() + { + e.applied_rules.push(AppliedRule { + rule_id: rules[n].clone(), + name: format!("Rule {}", n + 1), + action: action.to_string(), + stage: stage.to_string(), + }); + } + rows.push(e); + } + assert!(valid_evidence(&rows, session, &rules)); + let mut swapped = rows.clone(); + swapped[0].original_request = rows[1].original_request.clone(); + swapped[1].original_request = rows[0].original_request.clone(); + assert!(!valid_evidence(&swapped, session, &rules)); + let mut missing = rows.clone(); + missing.pop(); + assert!(!valid_evidence(&missing, session, &rules)); + let mut corrupt = rows.clone(); + corrupt[0].applied_rules.swap(0, 1); + assert!(!valid_evidence(&corrupt, session, &rules)); + let mut corrupt = rows.clone(); + corrupt[0].applied_rules[1].rule_id = "wrong".into(); + assert!(!valid_evidence(&corrupt, session, &rules)); + let mut corrupt = rows.clone(); + corrupt[0].completed = false; + assert!(!valid_evidence(&corrupt, session, &rules)); + let mut corrupt = rows.clone(); + corrupt[0].url = rows[1].url.clone(); + assert!(!valid_evidence(&corrupt, session, &rules)); + let mut corrupt = rows.clone(); + corrupt[0].id = rows[1].id.clone(); + assert!(!valid_evidence(&corrupt, session, &rules)); + let mut corrupt = rows.clone(); + corrupt[0].original_response = None; + assert!(!valid_evidence(&corrupt, session, &rules)); +} + +// Catches unbounded collection and falsely claiming complete measurements after overflow. +#[test] +fn sample_collection_caps_memory_and_counts_overflow() { + let collector = SaveMetrics::default(); + collector.enabled.store(true, Ordering::Relaxed); + for _ in 0..SAVE_CAP + 3 { + collector.push(SaveSample::default()); + } + let samples = collector.take(); + assert_eq!(samples.samples.len(), SAVE_CAP); + assert_eq!(samples.dropped, 3); +} diff --git a/crates/scope-core/src/diagnostics/workload.rs b/crates/scope-core/src/diagnostics/workload.rs new file mode 100644 index 0000000..8ac147c --- /dev/null +++ b/crates/scope-core/src/diagnostics/workload.rs @@ -0,0 +1,241 @@ +use super::*; +use serde_json::json; +use tokio::task::JoinSet; + +pub(super) async fn run(samples: usize, workers: usize) -> Value { + let mut cases = Vec::new(); + let mut passed = true; + for tls in [false, true] { + for sample in 0..samples { + let case = batch(tls, sample).await; + passed &= case["status"] == "PASS"; + cases.push(case); + } + } + // Known blocking case exercises both probes on an actual current-thread runtime. + // On the two-worker runtime the other worker can progress: control intentionally NOT RUN. + let timer_control = if workers == 0 { + let probes = probes::Probes::start().await; + let control_start = Instant::now(); + std::thread::sleep(Duration::from_millis(300)); + let control_end = Instant::now(); + let report = probes.finish(control_start, control_end).await; + let detected = report.detects_control(); + passed &= detected; + json!({"status":if detected {"PASS"} else {"FAIL"}, "injected_block_ms":300,"detector_threshold_ms":100,"probes":report}) + } else { + json!({"status":"NOTRUN","reason":"intentional blocking control requires current-thread runtime"}) + }; + json!({"schema":1,"status":if passed {"PASS"} else {"FAIL"},"workers":workers, + "profile":if cfg!(debug_assertions) {"debug"} else {"release"}, + "runtime":if workers==0 {"current_thread"} else {"multi_thread"}, + "cases":cases,"timer_network_positive_control":timer_control, + "not_run":{"queue_wait":"no writer queue exists", "disk_flush_count":"not observed", "sqlite_busy_wait_separate":"included in statement elapsed", "production_performance":"synthetic test-only harness", "gui_android":"outside harness"}}) +} + +fn install_rules(engine: &Engine) -> [String; 3] { + let actions = [ + json!({"type":"rewriteRequest","body":"request rule"}), + json!({"type":"mockResponse","status":201,"body":"mock body"}), + json!({"type":"rewriteResponse","body":"response rule"}), + ]; + std::array::from_fn(|i| { + engine + .save_rule( + serde_json::from_value( + json!({"id":"","name":format!("Rule {}",i+1),"enabled":true,"priority":i+1, + "matcher":{"pathPrefix":"/pause"},"action":actions[i]}), + ) + .unwrap(), + ) + .unwrap() + .id + }) +} +fn sqlite_settings(engine: &Engine) -> Value { + let db = engine.inner.db.lock().unwrap(); + let text = |pragma: &str| db.query_row(pragma, [], |r| r.get::<_, String>(0)).unwrap(); + let integer = |pragma: &str| db.query_row(pragma, [], |r| r.get::<_, i64>(0)).unwrap(); + let mut stmt = db.prepare("PRAGMA compile_options").unwrap(); + let options: Vec = stmt + .query_map([], |r| r.get(0)) + .unwrap() + .map(|r| r.unwrap()) + .collect(); + json!({"version":rusqlite::version(),"journal_mode":text("PRAGMA journal_mode"), + "synchronous":integer("PRAGMA synchronous"),"busy_timeout_ms":integer("PRAGMA busy_timeout"), + "page_size":integer("PRAGMA page_size"),"cache_size":integer("PRAGMA cache_size"), + "wal_autocheckpoint":integer("PRAGMA wal_autocheckpoint"),"compile_options":options}) +} +async fn batch(tls: bool, sample: usize) -> Value { + let dir = tempfile::tempdir().unwrap(); + let engine = Engine::open(dir.path()).unwrap(); + let session = engine + .create_session("Synthetic measurement".into(), "test".into()) + .unwrap(); + let rules = install_rules(&engine); + let settings = sqlite_settings(&engine); + let revision_before = engine.session(&session.id).unwrap().revision; + let proxy = engine.start_proxy(session.id.clone(), 0).await.unwrap(); + let client = reqwest::Client::builder() + .proxy(reqwest::Proxy::all(format!("http://127.0.0.1:{}", proxy.port)).unwrap()) + .add_root_certificate( + reqwest::Certificate::from_pem(&std::fs::read(engine.ca_cert_path()).unwrap()).unwrap(), + ) + .timeout(Duration::from_secs(30)) + .http1_only() + .build() + .unwrap(); + let probes = probes::Probes::start().await; + engine + .inner + .save_metrics + .enabled + .store(true, Ordering::Relaxed); + let began = Instant::now(); + let deadline = tokio::time::Instant::now() + Duration::from_secs(60); + let barrier = Arc::new(tokio::sync::Barrier::new(CLIENTS + 1)); + let mut clients = JoinSet::new(); + for i in 0..CLIENTS { + let (client, barrier) = (client.clone(), barrier.clone()); + clients.spawn(async move { + barrier.wait().await; + let started = Instant::now(); + let response = async { + let response = client + .get(format!( + "{}://localhost:1/pause?i={i}", + if tls { "https" } else { "http" } + )) + .header("x-measure-index", i.to_string()) + .send() + .await?; + let status = response.status(); + let body = response.bytes().await?; + Ok::<_, reqwest::Error>(status == 201 && body.as_ref() == b"response rule") + } + .await; + (ns(started.elapsed()), response.unwrap_or(false)) + }); + } + barrier.wait().await; + let mut timed_out = false; + let mut elapsed = Vec::with_capacity(CLIENTS); + let mut successful = 0; + let mut joined = 0; + while !clients.is_empty() { + let next = if timed_out { + clients.join_next().await + } else { + match tokio::time::timeout_at(deadline, clients.join_next()).await { + Ok(next) => next, + Err(_) => { + timed_out = true; + clients.abort_all(); + continue; + } + } + }; + if let Some(next) = next { + joined += 1; + if let Ok((ns, ok)) = next { + elapsed.push(ns); + successful += usize::from(ok); + } + } + } + let batch_end = Instant::now(); + let batch_ns = ns(batch_end.duration_since(began)); + engine + .inner + .save_metrics + .enabled + .store(false, Ordering::Relaxed); + let saves = engine.inner.save_metrics.take(); + let probe_report = probes.finish(began, batch_end).await; + let shutdown = Instant::now(); + engine.stop_proxy().await.unwrap(); + let shutdown_ns = ns(shutdown.elapsed()); + drop(client); + let rows = engine + .list_exchanges(&session.id, None, CLIENTS + 1, 0) + .unwrap(); + let evidence = valid_evidence(&rows, &session.id, &rules); + let revision_delta = engine.session(&session.id).unwrap().revision - revision_before; + let stored = rows.len(); + let original_ids = rows.iter().map(|r| r.id.clone()).collect::>(); + drop(rows); + drop(engine); + let reopened = Engine::open(dir.path()).unwrap(); + let rows = reopened + .list_exchanges(&session.id, None, CLIENTS + 1, 0) + .unwrap(); + let reopened_ok = valid_evidence(&rows, &session.id, &rules) + && rows.iter().map(|r| r.id.clone()).collect::>() == original_ids; + // Real persisted corruption in this disposable synthetic archive, after baseline readback. + // Detect both row loss and lost rule evidence through the same archive validator. + let db = reopened.inner.db.lock().unwrap(); + if let Some(row) = rows.first() { + db.execute( + "UPDATE exchanges SET data=json_remove(data,'$.appliedRules[1]') WHERE id=?1", + [&row.id], + ) + .unwrap(); + } + drop(db); + let corruption_detected = !valid_evidence( + &reopened + .list_exchanges(&session.id, None, CLIENTS + 1, 0) + .unwrap(), + &session.id, + &rules, + ); + // Restore the original persisted evidence before an independent row-loss control. + if let Some(row) = rows.first() { + reopened.save(row).unwrap(); + } + let restored_ok = valid_evidence( + &reopened + .list_exchanges(&session.id, None, CLIENTS + 1, 0) + .unwrap(), + &session.id, + &rules, + ); + let db = reopened.inner.db.lock().unwrap(); + if let Some(row) = rows.first() { + db.execute("DELETE FROM exchanges WHERE id=?1", [&row.id]) + .unwrap(); + } + drop(db); + let loss_detected = !valid_evidence( + &reopened + .list_exchanges(&session.id, None, CLIENTS + 1, 0) + .unwrap(), + &session.id, + &rules, + ); + let save_ok = + saves.dropped == 0 && saves.samples.len() == 192 && saves.samples.iter().all(|s| s.success); + let wall_budget_exceeded = + batch_ns > 60_000_000_000 || elapsed.iter().any(|&n| n > 30_000_000_000); + let passed = !wall_budget_exceeded + && !timed_out + && joined == 32 + && successful == 32 + && evidence + && reopened_ok + && save_ok + && revision_delta == 192 + && corruption_detected + && restored_ok + && loss_detected + && probe_report.covered(); + json!({"status":if passed {"PASS"} else {"FAIL"},"sample":sample,"transport":if tls {"TLS"} else {"HTTP"}, + "clients":32,"joined":joined,"successful":successful,"client_elapsed_ns":elapsed,"batch_elapsed_ns":batch_ns, + "shutdown_elapsed_ns":shutdown_ns,"cooperative_batch_timeout":timed_out,"wall_budget_exceeded":wall_budget_exceeded,"client_timeout_s":30,"batch_timeout_s":60, + "persisted_rows":stored,"evidence_valid":evidence,"reopened_evidence_valid":reopened_ok,"revision_delta":revision_delta, + "evidence_corruption_control_detected":corruption_detected,"evidence_loss_control_detected":loss_detected,"control_baseline_restored":restored_ok, + "save_cap":SAVE_CAP,"saves":saves,"probes":probe_report,"sqlite":settings, + "client_configuration":{"http":"1.1 only","pool":"shared client clones","tls":"fresh archive and client per batch; interception CA trusted; no external upstream","barrier":32}, + "storage":"fresh temporary file-backed archive; no PRAGMA overrides"}) +} diff --git a/crates/scope-core/src/lib.rs b/crates/scope-core/src/lib.rs index 91a51de..c6c3d4f 100644 --- a/crates/scope-core/src/lib.rs +++ b/crates/scope-core/src/lib.rs @@ -1,6 +1,8 @@ //! Local, durable HTTP(S) interception engine shared by Scope desktop and MCP. //! Buffers bodies up to 16 MiB. Larger bodies fail explicitly; no partial body //! is presented as a successful capture. WebSocket frames and trailers are not captured. +#[cfg(test)] +mod diagnostics; mod proxy; mod report; mod rules; @@ -166,6 +168,8 @@ pub struct Engine { } struct Inner { db: Mutex, + #[cfg(test)] + save_metrics: diagnostics::SaveMetrics, dir: PathBuf, rules: std::sync::RwLock>>, running: Mutex>, @@ -252,6 +256,8 @@ impl Engine { Ok(Self { inner: Arc::new(Inner { db: Mutex::new(db), + #[cfg(test)] + save_metrics: diagnostics::SaveMetrics::default(), dir, rules: std::sync::RwLock::new(rules), running: Mutex::new(None), @@ -319,8 +325,28 @@ impl Engine { .ok_or_else(|| anyhow!("Session not found: {id}")) } pub(crate) fn save(&self, e: &Exchange) -> Result<()> { + #[cfg(test)] + let started = self.inner.save_metrics.start(); let data = serde_json::to_string(e)?; - self.inner.db.lock().unwrap().execute("INSERT INTO exchanges VALUES(?1,?2,?3,?4) ON CONFLICT(id) DO UPDATE SET data=excluded.data",params![e.id,e.session_id,e.started_at,data])?; + #[cfg(test)] + let serialized = std::time::Instant::now(); + let db = self.inner.db.lock().unwrap(); + #[cfg(test)] + let acquired = std::time::Instant::now(); + let result = db.execute("INSERT INTO exchanges VALUES(?1,?2,?3,?4) ON CONFLICT(id) DO UPDATE SET data=excluded.data",params![e.id,e.session_id,e.started_at,data]); + #[cfg(test)] + let finished = std::time::Instant::now(); + drop(db); + #[cfg(test)] + self.inner.save_metrics.record( + started, + serialized, + acquired, + finished, + data.len(), + result.is_ok(), + ); + result?; Ok(()) } pub fn get_exchange(&self, id: &str) -> Result { diff --git a/docs/ARCHIVE_RESPONSIVENESS.md b/docs/ARCHIVE_RESPONSIVENESS.md new file mode 100644 index 0000000..81d045d --- /dev/null +++ b/docs/ARCHIVE_RESPONSIVENESS.md @@ -0,0 +1,157 @@ +# Archive-write responsiveness investigation + +This investigates [#28](https://github.com/dalkedev/scope/issues/28) against +Scope 1.2.2. It does not change production scheduling, SQLite settings, capture +limits, response ordering, native security settings or existing test deadlines. +Six `Engine::save` calls per successful mock exchange mean 192 upserts for 32 +requests. That is **not** a count of disk flushes. + +## Reproduce + +Use the pinned Rust 1.99.1 toolchain, Python 3.12 and the locked dependencies: + +```sh +python scripts/measure-archive.py --profiles debug release --samples 3 --workers 0 2 --output-dir .runtime/archive-measurement +``` + +The ignored unit-test harness and all observers are compiled only with +`cfg(test)`; no diagnostic API or collector ships in the application. Normal +CI runs deterministic detector regressions, not the ignored timing workload. +The existing Build and check workflow has a manual `archive-measurement` +diagnostic choice. Dispatch it explicitly against the reviewed branch: + +```sh +gh workflow run checks.yml --ref YOUR_BRANCH -f diagnostic=archive-measurement +``` + +Only the dedicated measurement jobs run on manual dispatch. Regular push/PR +checks keep their existing commands. Dispatch has a separate concurrency group, +contents-read permission, existing commit-pinned actions, no system-package installation +or native-security changes, and a 45-minute job limit. Each runner exports one +allowlisted numeric JSON artifact; compiler logs, archives and temporary CA keys +are excluded. The Python runner has an overall 30-minute budget, bounded builds +and child processes, and kills/reaps children on hard timeout. A failure to +establish process-tree cleanup ends further sampling. + +## Workload and interpretation + +Each runtime/profile combination runs three independent HTTP and three TLS +batches, each using a fresh temporary file-backed archive and client pool. +Thirty-two barrier-released logical requests use shared reqwest client clones, +HTTP/1.1, a 30-second client deadline and 60-second cooperative batch deadline. +These are logical clients, not a claim of 32 simultaneous network connections. +URLs target only loopback; three real rules rewrite the empty request, mock a +201 response, and rewrite that response. TLS uses actual CONNECT interception +and the newly generated CA. Nothing is sent to an external origin. + +Client status/body, exact request-index coverage, unique exchange IDs, original +request URL/method/body/pairing header, original response status/body, all ordered +rule IDs/names/actions/stages, completion/error/provenance, session revision +increments and reopened archive evidence are checked. A batch must produce 32 +rows and 192 successful save samples/revision increments, without overflow. +Independent controls corrupt rule evidence, restore/revalidate the baseline, +then delete a row; the same detector must reject both corrupted archives. + +Save samples time actual serialization, connection-mutex acquisition and the +existing SQLite statement. Samples are collected **after** releasing the DB +guard, at most 256 per batch, with overflow accounting. SQL elapsed includes +SQLite internal locks, triggers, checkpoint/autocommit work and OS effects; +it does not separate fsync, storage service time or SQLite busy-handler wait. +Queue wait is NOT RUN because there is no writer queue. Summed per-save durations +may overlap between workers and must not be equated to batch wall time. +Instrumentation has overhead; this is an observed test build, not an unobserved +production benchmark. + +A 10ms absolute-deadline heartbeat runs on the measured Tokio runtime. A separate +OS thread connects to a loopback echo socket served by that runtime, with finite +connect/read/write deadlines. Probes are ready before load. The report records +scheduled/start/end times, skipped timer periods, failures and exact workload +window membership; use only `in_window` samples for workload responsiveness. +Drain observations remain distinguishable. Sub-period batches can have no +in-window sample and explicitly report NOTRUN. No timing threshold gates normal +batches. A separate current-thread control intentionally blocks for 300ms and +requires both timer and network detectors to reject that interval using a 100ms +threshold. Two-worker control is NOT RUN, because another worker could progress. +Probe collectors cap at 8192 entries each; overflow invalidates results. + +Setup (including CA/session/rule creation), probe drain, proxy shutdown and +archive validation are outside batch timing. Shutdown time is reported separately. +Batch timing starts before spawning/releasing clients. Cooperative timeout flags +and observed wall-budget violations are both reported; only the external parent +can bound a runtime blocked in synchronous code. + +Metadata records commit/dirty state, compiler, OS/architecture, profile, runtime +worker count, build concurrency, SQLite version/compile options and actual +journal/synchronous/busy-timeout/page/cache/checkpoint settings. Logical CPU, +affinity and cgroup limits are recorded where exposed. Unknown memory/I/O quotas, +filesystem type and peak RSS are NOT RUN, not assumed unlimited. User Cargo +configuration is not inspected; clean hosted runs are the controlled profile +reference. Do not compare debug and release or differently constrained hosts as +if they were matched experiments. + +## Result provenance + +Hosted Linux: **NOT RUN** (awaiting reviewed dispatch). +Hosted Windows: **NOT RUN** (awaiting reviewed dispatch). +Local debug smoke: all four HTTP/TLS × current-thread/two-worker batches passed +with one sample per case, including both detector controls. This is a harness +smoke check, not comparative performance evidence. Hosted result artifacts and +exact source/run provenance will replace the pending entries before delivery. + +GUI/Android, real captures, external endpoints, sustained/large-body workloads, +fsync counts, isolated storage latency and production performance: **NOT RUN**. + +## Bounded writer proposal (not implemented) + +Start with scheduling isolation, not transaction batching: one blocking writer +owns the SQLite connection, retains existing WAL/synchronous/busy settings and +executes each accepted save exactly once in order. An acknowledged command is a +persistence barrier, including saves before breakpoint inspection and the final +save before returning a successful response. Read operations requiring the +latest evidence must wait for their preceding barrier; rule snapshots remain +atomic per request. Preserve revision-trigger counts and original snapshots. + +A candidate queue has eight command slots, at most one outstanding command per +exchange, and a 128MiB byte budget covering queued **and active** serialized +payloads. Acquire capacity before constructing another snapshot buffer. A full +queue applies bounded waiting to the producer, with an explicit cancellation or +overload result; no dropped writes, successful response or unbounded task-per-save +fallback is permitted. Reserve finalization capacity before admitting a capture +so overload cannot deadlock its terminal error write. Resource reservations are +released only after acknowledgement/finalization, not when a waiting future drops. + +This is a proposal, not a claim that eight slots or 128MiB is optimal. The +existing 16MiB body limit does not bound an entire JSON exchange with headers, +encoding and original snapshots. Before implementation, establish an exact +maximum encoded command size. If valid records exceed the byte budget, use a +bounded streaming/spooled representation (coordinated with #12), or reject the +design; silently reducing accepted payloads or claiming a complete memory bound +from queue length alone is unacceptable. Existing capture memory is a separate +budget and must also be measured. No production switch is justified until this +prerequisite and overload/finalization tests are satisfied. + +Cancellation before enqueue creates no accepted command. After enqueue, ownership +passes to the writer; cancellation must still await/record finalization. Stop +closes admission for the affected capture generation, cancels its network work, +drains accepted writes and terminal error records, then acknowledges shutdown. +Replay ownership stays associated with its original session/generation. Never +allow a late write to target a replacement capture. Restart continues the current +interrupted-capture recovery contract; test crashes before/after final commit and +acknowledgement, including committed-but-unacknowledged commands. + +On serialization/SQLite/full-disk/lock failures, propagate a specific failure to +every affected producer. Never return successful traffic without required final +evidence. Terminal persistence failure must surface as such, not be presented as +an archived error. Retain the existing finite busy timeout. Do not automatically +retry a commit with uncertain outcome. Verify rollback/autocommit state and stop +admission when storage state cannot be established. + +Only after scheduling isolation is measured should a second experiment batch +independent exchanges (for example up to eight commands or 2ms). Preserve per- +exchange ordering; acknowledge every barrier only after transaction commit. No +coalescing across breakpoint/finalization barriers, missing revision increments, +or response-before-commit is allowed. Rollback fails all commands in the group. +Acceptance must include stalled/locked storage, saturation, cancelled/replayed +captures, Stop races, crash/reopen and error-finalization tests plus matched +profiles. This increment deliberately supplies measurement and design, not that +unproven production change. Issue #28 remains open. diff --git a/docs/VERIFICATION.md b/docs/VERIFICATION.md index 525119f..a7ab765 100644 --- a/docs/VERIFICATION.md +++ b/docs/VERIFICATION.md @@ -1,5 +1,8 @@ # Recorded verification +For the separate opt-in archive measurement harness, result provenance and proposed +bounded writer, see [Archive responsiveness](ARCHIVE_RESPONSIVENESS.md). + ## Concurrent rule fixture follow-up — 2026-11-06 At `2ada212`, the [Windows job](https://github.com/dalkedev/scope/actions/runs/42281855023/job/128112730439) diff --git a/docs/superpowers/plans/2026-11-06-archive-measurement.md b/docs/superpowers/plans/2026-11-06-archive-measurement.md new file mode 100644 index 0000000..b52821e --- /dev/null +++ b/docs/superpowers/plans/2026-11-06-archive-measurement.md @@ -0,0 +1,45 @@ +# Archive Measurement Implementation Plan + +> **For agentic workers:** Use superpowers:executing-plans for inline implementation and a fresh independent whole-source review. + +**Goal:** Reproducible bounded evidence for #28 without a production rewrite. +**Architecture:** Ignored unit harness, test-only per-engine probes, hard-bounded Python runner. +**Tech Stack:** Existing locked Rust/Tokio/rusqlite/reqwest and Python standard library. +**Spec:** `docs/superpowers/specs/2026-11-06-archive-measurement-design.md` + +## Global constraints + +32 logical clients, 30s request/60s cooperative batch budgets, loopback only; +current-thread/two-worker runtimes; separate debug/release; three samples per +HTTP/TLS case; fixed numeric-only collectors; no durability/security changes. + +## Review focus + +- Timeout paths must stop and join probes/clients or be killed/reaped by parent. +- Collector overflow must invalidate complete-count claims. +- Missing/reordered evidence and request pairing errors must be rejected. +- Positive controls must exercise real timer/network and persisted evidence. +- Reports must not include arbitrary environment, paths, bodies or errors. + +### Task 1: Actual save instrumentation and evidence detector + +Files: `crates/scope-core/src/lib.rs`, `src/diagnostics.rs` and submodules. +- [x] Write detector tests for missing, reordered, wrong-ID and incomplete evidence, plus capped sample collection; observe RED. +- [x] Implement test-only collector and validator; observe GREEN. +- [x] Instrument actual serialization, mutex and statement boundaries without changing SQL or production order. + +### Task 2: Synthetic runtime workload and probes + +Files: diagnostic submodules, `scripts/measure-archive.py`, runner unit tests. +- [x] Add ignored harness with real HTTP/TLS interception and all existing evidence semantics. +- [x] Add ready-before-load timer and independent-thread network probes, bounded cleanup and positive controls. +- [x] Add hard parent deadline, profile matrix, sanitized metadata and output validation. +- [x] Run local locked core/headless suites, controls and a small real measurement. + +### Task 3: Hosted evidence and proposal + +Files: measurement workflow, `docs/ARCHIVE_RESPONSIVENESS.md`, allowlisted result JSON. +- [ ] Review complete source before a single branch push/dispatch, reconcile receipts. +- [ ] Obtain actual hosted Linux/Windows debug/release results and verify artifact provenance. +- [ ] Document bounded writer ordering, backpressure, cancellation/restart/error guarantees from evidence. +- [ ] Independent whole-branch review, affected tests, final PR referencing #28 and exact remote/body readback. diff --git a/docs/superpowers/specs/2026-11-06-archive-measurement-design.md b/docs/superpowers/specs/2026-11-06-archive-measurement-design.md new file mode 100644 index 0000000..696dc8e --- /dev/null +++ b/docs/superpowers/specs/2026-11-06-archive-measurement-design.md @@ -0,0 +1,53 @@ +# Synthetic archive responsiveness investigation + +Issue: #28. Baseline: Scope 1.2.2, `0f1d91852d2d3884f472ff10e6d7e4eabae3b80e`. + +## Intent and constraints + +Measure the current synchronous archive path before considering a writer rewrite. +All traffic is synthetic and loopback-only. No production persistence, security, +durability, response ordering, capture limits or existing deadlines change. +The deliverable is a reviewed harness, actual Linux/Windows evidence and an +explicit bounded-writer proposal; a production rewrite is outside this increment. + +## Approach + +Use an ignored unit-test harness and `cfg(test)` per-engine save instrumentation. +This keeps diagnostics out of shipping binaries and avoids a public diagnostic API. +A feature-gated binary would also work but adds a shipping feature surface; an +external-only benchmark cannot separate serialization, mutex and SQL time. + +The existing save statement is timed at its actual boundaries. Collect numeric +samples after dropping the connection guard, with a fixed cap and overflow count. +Record unsuccessful statements. Queue wait is NOT RUN: this implementation has +no writer queue. SQL time includes SQLite locking, triggers and autocommit; it +is neither a disk-flush count nor isolated filesystem latency. + +For each profile, run current-thread and two-worker Tokio runtimes, HTTP and TLS, +three fresh-archive samples each. Each batch has 32 concurrent logical requests +sharing a reqwest client pool, the existing three rewrite/mock rules, 30-second +clients and a 60-second cooperative batch deadline. Check exact responses, +request-index coverage, unique exchange IDs, original snapshots, all ordered +rule evidence, session revisions and reopened archive evidence. Report client, +batch and shutdown elapsed time separately. Do not export rows, bodies, IDs, +URLs, certificates or filesystem paths. + +A heartbeat uses monotonic absolute deadlines; an independent OS thread probes +an echo socket served on the same runtime. Both start before the batch. A parent +Python process enforces a hard child-process timeout. Fixed sample caps bound +memory, including probes. Separate positive controls intentionally block the +current-thread runtime and corrupt synthetic persisted evidence, proving the +same detectors reject known failures. Timing thresholds apply only to controls, +never normal CI or real benchmark acceptance. + +Metadata records compiler/profile/workers, SQLite readback, sample bounds, +platform and observable resource limits. Unknown measurements are NOT RUN. +Hosted workflow has contents-read only, pinned existing actions, bounded jobs, +no host package or security changes, and uploads only allowlisted numeric JSON. + +## Review focus + +Detector blindness, probe starvation, dropped samples, timeout cleanup, profile +mismatch, ambiguous GitHub writes, accidental private diagnostics, and unsupported +causal claims. Independent design review precedes implementation; complete-source +review precedes dispatch and PR completion. diff --git a/scripts/measure-archive.py b/scripts/measure-archive.py new file mode 100644 index 0000000..b24f24c --- /dev/null +++ b/scripts/measure-archive.py @@ -0,0 +1,368 @@ +#!/usr/bin/env python3 +"""Opt-in synthetic archive measurement. Exports only bounded numeric diagnostics. + +No external endpoints, native security changes, production configuration changes, +or timing gates in normal CI. Build/test output remains in a disposable directory. +""" +import argparse +import json +import os +from pathlib import Path +import platform +import re +import signal +import subprocess +import sys +import tempfile +import time + +ROOT = Path(__file__).resolve().parents[1] +WINDOWS = os.name == 'nt' + + +def run_bounded(command, cwd, env, timeout): + """Kill/reap after a hard deadline; expose uncertainty about descendants.""" + kwargs = {'start_new_session': True} if os.name != 'nt' else {'creationflags': subprocess.CREATE_NEW_PROCESS_GROUP} + with tempfile.TemporaryFile() as output: + child = subprocess.Popen(command, cwd=cwd, env=env, stdout=output, stderr=subprocess.STDOUT, **kwargs) + timed_out = False + cleanup_uncertain = False + try: + child.wait(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + if WINDOWS: + try: + killed = subprocess.run(['taskkill', '/PID', str(child.pid), '/T', '/F'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=10, check=False) + cleanup_uncertain = killed.returncode != 0 + except (OSError, subprocess.TimeoutExpired): + cleanup_uncertain = True # Direct kill cannot confirm descendant cleanup. + else: + try: + os.killpg(child.pid, signal.SIGKILL) + except ProcessLookupError: + pass + if child.poll() is None: + child.kill() + child.wait(timeout=10) + output.seek(0) + # Cargo JSON is bounded here; do not export compiler output or local paths. + captured = output.read(16 * 1024 * 1024).decode('utf-8', errors='replace') + return {'status': 'TIMEOUT' if timed_out else ('PASS' if child.returncode == 0 else 'FAIL'), + 'returncode': child.returncode, 'output': captured, 'cleanup_uncertain': cleanup_uncertain} + + +def validate_report(report, profile, workers, samples): + """Accept only the explicit, bounded synthetic report schema; never raw data.""" + def reject(): + raise ValueError('invalid synthetic diagnostic schema') + + def obj(value, keys): + if type(value) is not dict or set(value) != set(keys.split()): + reject() + return value + + def integer(value, low=0, high=(1 << 64) - 1): + if type(value) is not int or not low <= value <= high: + reject() + return value + + def boolean(value): + if type(value) is not bool: + reject() + return value + + def fixed(value, expected): + if type(value) is not type(expected) or value != expected: + reject() + + def choice(value, allowed): + if type(value) is not str or value not in allowed: + reject() + + def array(value, cap): + if type(value) is not list or len(value) > cap: + reject() + return value + + def probes(value): + obj(value, 'timer network period_ms cap_per_probe window_start_ns window_end_ns') + fixed(value['period_ms'], 10) + fixed(value['cap_per_probe'], 8192) + start = integer(value['window_start_ns']) + end = integer(value['window_end_ns'], start) + for name in ('timer', 'network'): + series = obj(value[name], 'elapsed_ns samples failures dropped missed_periods in_window_samples window_status') + for key in ('failures', 'dropped', 'missed_periods', 'in_window_samples'): + integer(series[key]) + elapsed = array(series['elapsed_ns'], 8192) + for number in elapsed: + integer(number) + observations = array(series['samples'], 8192) + for observation in observations: + obj(observation, 'scheduled_ns start_ns end_ns elapsed_ns success in_window') + began = integer(observation['start_ns']) + ended = integer(observation['end_ns'], began) + measured = integer(observation['elapsed_ns']) + boolean(observation['success']) + boolean(observation['in_window']) + if name == 'timer': + scheduled = integer(observation['scheduled_ns'], high=began) + expected_window = end > start and start <= scheduled < end + fixed(measured, began - scheduled) + fixed(ended, began) + fixed(observation['success'], True) + else: + fixed(observation['scheduled_ns'], None) + expected_window = end > start and began < end and ended > start + fixed(measured, ended - began) + fixed(observation['in_window'], expected_window) + if elapsed != [s['elapsed_ns'] for s in observations if s['success']]: + reject() + fixed(series['in_window_samples'], sum(s['in_window'] for s in observations)) + expected_status = 'INVALID' if series['dropped'] else ('PASS' if series['in_window_samples'] else 'NOTRUN') + fixed(series['window_status'], expected_status) + recorded_failures = sum(not s['success'] for s in observations) + if not recorded_failures <= series['failures'] <= recorded_failures + series['dropped']: + reject() + return value + + # Options are emitted by the pinned bundled SQLite. Permit platform/compiler + # differences, never arbitrary option names, prose, filesystem paths or URLs. + option_names = set('''ATOMIC_INTRINSICS DEFAULT_AUTOVACUUM DEFAULT_CACHE_SIZE DEFAULT_FILE_FORMAT + DEFAULT_FOREIGN_KEYS DEFAULT_JOURNAL_SIZE_LIMIT DEFAULT_MMAP_SIZE DEFAULT_PAGE_SIZE + DEFAULT_PCACHE_INITSZ DEFAULT_RECURSIVE_TRIGGERS DEFAULT_SECTOR_SIZE DEFAULT_SYNCHRONOUS + DEFAULT_WAL_AUTOCHECKPOINT DEFAULT_WAL_SYNCHRONOUS DEFAULT_WORKER_THREADS DIRECT_OVERFLOW_READ + ENABLE_API_ARMOR ENABLE_COLUMN_METADATA ENABLE_DBSTAT_VTAB ENABLE_FTS3 ENABLE_FTS3_PARENTHESIS + ENABLE_FTS3_TOKENIZER ENABLE_FTS4 ENABLE_FTS5 ENABLE_LOAD_EXTENSION ENABLE_MATH_FUNCTIONS + ENABLE_MEMORY_MANAGEMENT ENABLE_RTREE ENABLE_STAT4 HAVE_ISNAN HAVE_LOCALTIME_R HAVE_LOCALTIME_S + HAVE_MALLOC_USABLE_SIZE HAVE_USLEEP MALLOC_SOFT_LIMIT MAX_ATTACHED MAX_COLUMN MAX_COMPOUND_SELECT + MAX_DEFAULT_PAGE_SIZE MAX_EXPR_DEPTH MAX_FUNCTION_ARG MAX_LENGTH MAX_LIKE_PATTERN_LENGTH + MAX_MMAP_SIZE MAX_PAGE_COUNT MAX_PAGE_SIZE MAX_SQL_LENGTH MAX_TRIGGER_DEPTH MAX_VARIABLE_NUMBER + MAX_VDBE_OP MAX_WORKER_THREADS MUTEX_NOOP MUTEX_PTHREADS MUTEX_W32 SOUNDEX SYSTEM_MALLOC + TEMP_STORE THREADSAFE USE_URI'''.split()) + + def sqlite(value): + obj(value, 'version journal_mode synchronous busy_timeout_ms page_size cache_size wal_autocheckpoint compile_options') + if type(value['version']) is not str or not re.fullmatch(r'3\.\d{1,3}\.\d{1,3}', value['version']): + reject() + fixed(value['journal_mode'], 'wal') + integer(value['synchronous'], 0, 3) + for key in ('busy_timeout_ms', 'page_size', 'wal_autocheckpoint'): + integer(value[key]) + integer(value['cache_size'], -(1 << 63), (1 << 63)-1) + options = array(value['compile_options'], 128) + for option in options: + if type(option) is not str or len(option) > 128: + reject() + if option.startswith('COMPILER='): + if not re.fullmatch(r'COMPILER=(?:(?:clang|gcc)-[0-9][0-9.]{0,30}|msvc-[0-9]{1,8})', option): + reject() + else: + match = re.fullmatch(r'([A-Z][A-Z0-9_]*)(?:=(-?(?:[0-9]{1,20}|0x[0-9a-fA-F]{1,16})))?', option) + if not match or match[1] not in option_names: + reject() + if len(set(options)) != len(options): + reject() + + if profile not in ('debug', 'release') or type(workers) is not int or workers not in (0, 2) or type(samples) is not int or not 1 <= samples <= 5: + reject() + obj(report, 'schema status profile workers runtime cases timer_network_positive_control not_run') + fixed(report['schema'], 1) + fixed(report['profile'], profile) + fixed(report['workers'], workers) + fixed(report['runtime'], 'current_thread' if workers == 0 else 'multi_thread') + choice(report['status'], ('PASS', 'FAIL')) + cases = array(report['cases'], 10) + fixed(len(cases), 2 * samples) + seen = set() + evidence_keys = ('evidence_valid', 'reopened_evidence_valid', 'evidence_corruption_control_detected', + 'evidence_loss_control_detected', 'control_baseline_restored') + for case in cases: + obj(case, '''status sample transport clients joined successful client_elapsed_ns batch_elapsed_ns + shutdown_elapsed_ns cooperative_batch_timeout wall_budget_exceeded client_timeout_s batch_timeout_s + persisted_rows evidence_valid reopened_evidence_valid revision_delta evidence_corruption_control_detected + evidence_loss_control_detected control_baseline_restored save_cap saves probes sqlite client_configuration storage''') + choice(case['status'], ('PASS', 'FAIL')) + choice(case['transport'], ('HTTP', 'TLS')) + integer(case['sample'], 0, samples-1) + identity = (case['transport'], case['sample']) + if identity in seen: + reject() + seen.add(identity) + for key, expected in [('clients', 32), ('client_timeout_s', 30), ('batch_timeout_s', 60), ('save_cap', 256)]: + fixed(case[key], expected) + for key in ('joined', 'successful'): + integer(case[key], 0, 32) + integer(case['persisted_rows'], 0, 33) + integer(case['revision_delta'], -(1 << 63), (1 << 63)-1) + for key in ('batch_elapsed_ns', 'shutdown_elapsed_ns'): + integer(case[key]) + for key in evidence_keys + ('cooperative_batch_timeout', 'wall_budget_exceeded'): + boolean(case[key]) + for number in array(case['client_elapsed_ns'], 32): + integer(number) + saves = obj(case['saves'], 'dropped samples') + integer(saves['dropped']) + for sample in array(saves['samples'], 256): + obj(sample, 'serialization_ns mutex_wait_ns statement_ns serialized_bytes success') + for key in ('serialization_ns', 'mutex_wait_ns', 'statement_ns', 'serialized_bytes'): + integer(sample[key]) + boolean(sample['success']) + probes(case['probes']) + sqlite(case['sqlite']) + configuration = obj(case['client_configuration'], 'http pool tls barrier') + for key, expected in [('http', '1.1 only'), ('pool', 'shared client clones'), + ('tls', 'fresh archive and client per batch; interception CA trusted; no external upstream'), ('barrier', 32)]: + fixed(configuration[key], expected) + fixed(case['storage'], 'fresh temporary file-backed archive; no PRAGMA overrides') + if case['status'] == 'PASS': + if not (case['joined'] == case['successful'] == case['persisted_rows'] == len(case['client_elapsed_ns']) == 32 + and all(case[key] for key in evidence_keys) and case['revision_delta'] == 192 + and not case['cooperative_batch_timeout'] and not case['wall_budget_exceeded'] + and case['batch_elapsed_ns'] <= 60_000_000_000 + and all(n <= 30_000_000_000 for n in case['client_elapsed_ns']) + and saves['dropped'] == 0 and len(saves['samples']) == 192 + and all(s['success'] for s in saves['samples']) + and all(case['probes'][name]['dropped'] == 0 for name in ('timer', 'network'))): + reject() + control = report['timer_network_positive_control'] + if workers == 0: + obj(control, 'status injected_block_ms detector_threshold_ms probes') + choice(control['status'], ('PASS', 'FAIL')) + fixed(control['injected_block_ms'], 300) + fixed(control['detector_threshold_ms'], 100) + observed = probes(control['probes']) + if control['status'] == 'PASS' and not ( + any(s['in_window'] and s['elapsed_ns'] > 100_000_000 for s in observed['timer']['samples']) + and any(s['in_window'] and (not s['success'] or s['elapsed_ns'] > 100_000_000) for s in observed['network']['samples']) + and observed['timer']['dropped'] == observed['network']['dropped'] == 0): + reject() + else: + obj(control, 'status reason') + fixed(control['status'], 'NOTRUN') + fixed(control['reason'], 'intentional blocking control requires current-thread runtime') + not_run = obj(report['not_run'], 'queue_wait disk_flush_count sqlite_busy_wait_separate production_performance gui_android') + for key, expected in [('queue_wait', 'no writer queue exists'), ('disk_flush_count', 'not observed'), + ('sqlite_busy_wait_separate', 'included in statement elapsed'), + ('production_performance', 'synthetic test-only harness'), ('gui_android', 'outside harness')]: + fixed(not_run[key], expected) + if report['status'] == 'PASS' and not (all(case['status'] == 'PASS' for case in cases) and (workers == 2 or control['status'] == 'PASS')): + reject() + +def resource_limits(): + values = {'logical_cpus': os.cpu_count(), 'affinity_cpus': None, + 'cgroup_memory_max_bytes': None, 'cgroup_cpu_quota_us': None, 'cgroup_cpu_period_us': None, + 'peak_child_rss': 'NOTRUN', 'filesystem_type': 'NOTRUN', 'io_quota': 'NOTRUN'} + if hasattr(os, 'sched_getaffinity'): + values['affinity_cpus'] = len(os.sched_getaffinity(0)) + for field, file in [('cgroup_memory_max_bytes', '/sys/fs/cgroup/memory.max')]: + try: + text = Path(file).read_text().strip() + if text.isdigit(): + values[field] = int(text) + except OSError: + pass + try: + quota, period = Path('/sys/fs/cgroup/cpu.max').read_text().split() + values['cgroup_cpu_quota_us'] = int(quota) if quota.isdigit() else None + values['cgroup_cpu_period_us'] = int(period) + except (OSError, ValueError): + pass + return values + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--profiles', nargs='+', choices=['debug', 'release'], default=['debug', 'release']) + parser.add_argument('--samples', type=int, choices=range(1, 6), default=3) + parser.add_argument('--workers', type=int, nargs='+', choices=[0, 2], default=[0, 2]) + parser.add_argument('--output-dir', type=Path, required=True) + args = parser.parse_args() + output_dir = args.output_dir.resolve() + output_dir.mkdir(parents=True, exist_ok=True) + env = os.environ.copy() + # Comparisons must use the repository's declared profiles, not hidden tuning. + if any(key.startswith('CARGO_PROFILE_') or key.endswith('_RUSTFLAGS') for key in env) or any(env.get(key) for key in ('RUSTFLAGS', 'RUSTC_WRAPPER', 'RUSTC_WORKSPACE_WRAPPER')): + parser.error('remove profile/Rust flag overrides before measurement') + env['CARGO_BUILD_JOBS'] = '2' + revision = subprocess.check_output(['git', 'rev-parse', 'HEAD'], cwd=ROOT, text=True).strip() + if not re.fullmatch(r'[0-9a-f]{40}', revision): + parser.error('invalid source revision') + dirty = bool(subprocess.check_output(['git', 'status', '--porcelain'], cwd=ROOT)) + compiler = subprocess.check_output(['rustc', '--version'], text=True).strip() + if not re.fullmatch(r'rustc 1\.99\.1 \([a-z0-9]+ [0-9-]+\)', compiler): + parser.error('use the pinned Rust 1.99.1 compiler') + hosted = {} + for name in ('GITHUB_RUN_ID', 'GITHUB_RUN_ATTEMPT', 'ImageOS', 'ImageVersion'): + value = env.get(name) + hosted[name] = value if value and re.fullmatch(r'[a-zA-Z0-9._-]{1,80}', value) else None + metadata = {'source_commit': revision, 'source_dirty': dirty, 'compiler': compiler, + 'os': platform.system(), 'architecture': platform.machine(), 'python': platform.python_version(), + 'hosted': hosted, 'resources': resource_limits(), 'build_jobs': 2, + 'profiles': args.profiles, 'workers': args.workers, 'samples_per_transport': args.samples, + 'build_hard_timeout_s': 600, 'child_hard_timeout_s': 420, 'overall_budget_s': 1800, + 'optimization': {'debug': 'repository profile: opt-level=0,debug=1', 'release': 'repository profile: opt-level=3,lto=thin,strip=true'}, + 'profile_limits': 'environment flag/profile/wrapper overrides rejected; user Cargo configuration is not inspected; hosted jobs use clean checkout and toolchain', + 'storage': 'OS temporary directory; fresh file-backed SQLite archive per case; path omitted', + 'unavailable_resource_fields': 'null means NOTRUN or not exposed by this platform'} + results = [] + overall_deadline = time.monotonic() + 1800 + cleanup_uncertain = False + def bounded(command, child_env, maximum): + nonlocal cleanup_uncertain + if cleanup_uncertain: + return {'status': 'NOTRUN', 'returncode': None, 'output': '', 'cleanup_uncertain': True} + remaining = overall_deadline - time.monotonic() - 30 + if remaining <= 0: + return {'status': 'NOTRUN', 'returncode': None, 'output': '', 'cleanup_uncertain': False} + result = run_bounded(command, ROOT, child_env, min(maximum, remaining)) + cleanup_uncertain = result['cleanup_uncertain'] + return result + for profile in dict.fromkeys(args.profiles): + command = ['cargo', 'test', '--locked', '-p', 'scope-core', '--lib', '--no-run', '--message-format=json'] + if profile == 'release': + command.append('--release') + built = bounded(command, env, 600) + binary = None + if built['status'] == 'PASS': + for line in built['output'].splitlines(): + try: + event = json.loads(line) + except ValueError: + continue + if event.get('reason') == 'compiler-artifact' and event.get('target', {}).get('name') == 'scope_core' and event.get('profile', {}).get('test') and event.get('executable'): + binary = event['executable'] + if not binary: + results.append({'profile': profile, 'status': built['status'] if built['status'] != 'PASS' else 'FAIL', 'reason': 'cleanup_uncertain' if built['cleanup_uncertain'] else 'build_or_artifact_failure', 'cleanup_uncertain': built['cleanup_uncertain']}) + continue + for workers in dict.fromkeys(args.workers): + with tempfile.TemporaryDirectory(prefix='scope-measure-') as temp: + report_path = Path(temp) / 'report.json' + child_env = dict(env, SCOPE_MEASURE_OUTPUT=str(report_path), SCOPE_MEASURE_WORKERS=str(workers), SCOPE_MEASURE_SAMPLES=str(args.samples)) + result = bounded([binary, '--ignored', '--exact', 'diagnostics::archive_responsiveness', '--nocapture'], child_env, 420) + record = {'profile': profile, 'workers': workers, 'status': result['status'], 'reason': 'cleanup_uncertain' if result['cleanup_uncertain'] else None, 'report': None, 'cleanup_uncertain': result['cleanup_uncertain']} + if report_path.exists() and report_path.stat().st_size <= 8 * 1024 * 1024: + try: + report = json.loads(report_path.read_text(encoding='utf-8')) + validate_report(report, profile, workers, args.samples) + record['report'] = report + if report['status'] != 'PASS': + record['status'] = 'FAIL' + except (ValueError, TypeError, KeyError): + record['status'], record['reason'] = 'FAIL', 'invalid_report' + else: + if record['reason'] is None: + record['reason'] = 'report_unavailable' + if record['status'] == 'PASS': + record['status'] = 'FAIL' + results.append(record) + print(f'{profile} workers={workers}: {record["status"]}', flush=True) + summary = {'schema': 1, 'status': 'PASS' if results and all(r['status'] == 'PASS' for r in results) else 'FAIL', + 'metadata': metadata, 'results': results, 'cleanup_uncertain': cleanup_uncertain} + (output_dir / 'measurement.json').write_text(json.dumps(summary, indent=2) + '\n', encoding='utf-8') + return 0 if summary['status'] == 'PASS' else 1 + + +if __name__ == '__main__': + raise SystemExit(main()) diff --git a/scripts/tests/test_measure_archive.py b/scripts/tests/test_measure_archive.py new file mode 100644 index 0000000..68c518d --- /dev/null +++ b/scripts/tests/test_measure_archive.py @@ -0,0 +1,166 @@ +"""Behavioral tests for the bounded measurement process and report trust boundary.""" +import copy +import json +import importlib.util +from pathlib import Path +import sys +import tempfile +import unittest +from unittest.mock import patch +import subprocess + +SPEC = importlib.util.spec_from_file_location('measure_archive', Path(__file__).parents[1] / 'measure-archive.py') +measure = importlib.util.module_from_spec(SPEC) +SPEC.loader.exec_module(measure) + + +def valid_report(): + def probes(control=False): + start, end = (0, 300_000_000) if control else (100, 200) + timer_start, timer_end = (10_000_000, 300_000_000) if control else (150, 160) + timer = {'scheduled_ns': timer_start, 'start_ns': timer_end, 'end_ns': timer_end, + 'elapsed_ns': timer_end-timer_start, 'success': True, 'in_window': True} + network = dict(timer, scheduled_ns=None, start_ns=timer_start) + def values(sample): + return {'elapsed_ns':[sample['elapsed_ns']], 'samples':[sample], 'failures':0, + 'dropped':0, 'missed_periods':0, 'in_window_samples':1, 'window_status':'PASS'} + return {'timer':values(timer), 'network':values(network), 'period_ms':10, + 'cap_per_probe':8192, 'window_start_ns':start, 'window_end_ns':end} + case = {'status':'PASS', 'sample':0, 'transport':'HTTP', 'clients':32, 'joined':32, + 'successful':32, 'client_elapsed_ns':[50]*32, 'batch_elapsed_ns':100, + 'shutdown_elapsed_ns':1, 'cooperative_batch_timeout':False, 'wall_budget_exceeded':False, + 'client_timeout_s':30, 'batch_timeout_s':60, 'persisted_rows':32, 'evidence_valid':True, + 'reopened_evidence_valid':True, 'revision_delta':192, 'evidence_corruption_control_detected':True, + 'evidence_loss_control_detected':True, 'control_baseline_restored':True, 'save_cap':256, + 'saves':{'dropped':0,'samples':[{'serialization_ns':1,'mutex_wait_ns':1,'statement_ns':1, + 'serialized_bytes':100,'success':True} for _ in range(192)]}, + 'probes':probes(), 'sqlite':{'version':'3.51.1','journal_mode':'wal','synchronous':2, + 'busy_timeout_ms':5000,'page_size':4096,'cache_size':-2000,'wal_autocheckpoint':1000, + 'compile_options':['COMPILER=clang-22.1.8','THREADSAFE=1','MUTEX_PTHREADS']}, + 'client_configuration':{'http':'1.1 only','pool':'shared client clones', + 'tls':'fresh archive and client per batch; interception CA trusted; no external upstream','barrier':32}, + 'storage':'fresh temporary file-backed archive; no PRAGMA overrides'} + tls = copy.deepcopy(case); tls['transport'] = 'TLS' + return {'schema':1,'status':'PASS','workers':0,'profile':'debug','runtime':'current_thread', + 'cases':[case,tls], 'timer_network_positive_control':{'status':'PASS','injected_block_ms':300, + 'detector_threshold_ms':100,'probes':probes(True)}, 'not_run':{'queue_wait':'no writer queue exists', + 'disk_flush_count':'not observed','sqlite_busy_wait_separate':'included in statement elapsed', + 'production_performance':'synthetic test-only harness','gui_android':'outside harness'}} + + +class MeasurementRunnerTests(unittest.TestCase): + def test_hard_deadline_kills_and_reaps_stalled_child(self): + with tempfile.TemporaryDirectory() as directory: + result = measure.run_bounded([sys.executable, '-c', 'import time; time.sleep(10)'], Path(directory), {}, .1) + self.assertEqual(result['status'], 'TIMEOUT') + self.assertIsNotNone(result['returncode']) + + def test_taskkill_failure_still_kills_and_reaps_child(self): + with tempfile.TemporaryDirectory() as directory: + with patch.object(measure, 'WINDOWS', True), patch.object(measure.subprocess, 'run', side_effect=subprocess.TimeoutExpired('taskkill', 10)): + result = measure.run_bounded([sys.executable, '-c', 'import time; time.sleep(10)'], Path(directory), {}, .1) + self.assertEqual(result['status'], 'TIMEOUT') + self.assertIsNotNone(result['returncode']) + self.assertTrue(result['cleanup_uncertain']) + + def test_report_accepts_complete_numeric_fixture(self): + measure.validate_report(valid_report(), 'debug', 0, 1) + + def test_report_rejects_unknown_fields_at_every_boundary(self): + fixture = valid_report() + containers = [fixture, fixture['cases'][0], fixture['cases'][0]['saves'], + fixture['cases'][0]['saves']['samples'][0], fixture['cases'][0]['probes'], + fixture['cases'][0]['probes']['timer'], fixture['cases'][0]['probes']['timer']['samples'][0], + fixture['cases'][0]['sqlite'], fixture['cases'][0]['client_configuration'], + fixture['not_run'], fixture['timer_network_positive_control']] + for container in containers: + with self.subTest(keys=list(container)): + container['unexpected_secret'] = 'fixture-token' + with self.assertRaises(ValueError): + measure.validate_report(fixture, 'debug', 0, 1) + del container['unexpected_secret'] + + def test_report_rejects_injected_strings_missing_fields_and_wrong_types(self): + mutations = [lambda r: r['cases'][0].update(storage='fixture-token'), + lambda r: r['not_run'].update(queue_wait='fixture-token'), + lambda r: r['cases'][0]['sqlite'].update(compile_options=['SECRET=fixture-token']), + lambda r: r['cases'][0].pop('evidence_valid'), + lambda r: r['cases'][0].update(clients=True), + lambda r: r['cases'][0].update(batch_elapsed_ns=1.2), + lambda r: r['cases'][0].update(evidence_valid=1), + lambda r: r['cases'][0]['probes']['timer']['samples'][0].update(elapsed_ns=-1)] + for mutate in mutations: + fixture = valid_report(); mutate(fixture) + with self.assertRaises(ValueError): + measure.validate_report(fixture, 'debug', 0, 1) + + def test_taskkill_nonzero_result_marks_descendant_cleanup_uncertain(self): + with tempfile.TemporaryDirectory() as directory: + failed = subprocess.CompletedProcess(['taskkill'], 1) + with patch.object(measure, 'WINDOWS', True), patch.object(measure.subprocess, 'run', return_value=failed): + result = measure.run_bounded([sys.executable, '-c', 'import time; time.sleep(10)'], Path(directory), {}, .1) + self.assertEqual(result['status'], 'TIMEOUT') + self.assertTrue(result['cleanup_uncertain']) + self.assertIsNotNone(result['returncode']) + + def test_uncertain_cleanup_stops_all_subsequent_child_launches(self): + with tempfile.TemporaryDirectory() as directory: + args = ['measure-archive.py', '--profiles', 'debug', 'release', '--workers', '0', '2', + '--samples', '1', '--output-dir', directory] + uncertain = {'status':'TIMEOUT', 'returncode':-9, 'output':'', 'cleanup_uncertain':True} + with patch.object(sys, 'argv', args), patch.dict(measure.os.environ, {}, clear=True), \ + patch.object(measure.subprocess, 'check_output', side_effect=['a'*40, b'', 'rustc 1.99.1 (abcdef 2026-10-01)']), \ + patch.object(measure, 'resource_limits', return_value={}), \ + patch.object(measure, 'run_bounded', return_value=uncertain) as launch: + self.assertEqual(measure.main(), 1) + self.assertEqual(launch.call_count, 1) + summary = json.loads((Path(directory)/'measurement.json').read_text()) + self.assertTrue(summary['cleanup_uncertain']) + self.assertEqual(summary['status'], 'FAIL') + self.assertEqual([r['status'] for r in summary['results']], ['TIMEOUT', 'NOTRUN']) + self.assertTrue(all(r['reason'] == 'cleanup_uncertain' for r in summary['results'])) + + def test_report_accepts_release_two_worker_and_failed_diagnostics(self): + fixture = valid_report() + fixture.update(profile='release', workers=2, runtime='multi_thread', + timer_network_positive_control={'status':'NOTRUN', + 'reason':'intentional blocking control requires current-thread runtime'}) + measure.validate_report(fixture, 'release', 2, 1) + fixture['status'] = fixture['cases'][0]['status'] = 'FAIL' + fixture['cases'][0]['evidence_valid'] = False + measure.validate_report(fixture, 'release', 2, 1) + + def test_report_rejects_bounded_array_and_integer_overflow(self): + mutations = [lambda r: r['cases'][0].update(client_elapsed_ns=[1]*33), + lambda r: r['cases'][0]['saves'].update(samples=r['cases'][0]['saves']['samples']*2), + lambda r: r['cases'][0]['probes']['timer'].update(samples=[{}]*8193), + lambda r: r['cases'][0]['sqlite'].update(compile_options=['THREADSAFE=1']*129), + lambda r: r['cases'][0].update(batch_elapsed_ns=2**64), + lambda r: r['cases'][0].update(batch_elapsed_ns=float('nan'))] + for mutate in mutations: + fixture = valid_report(); mutate(fixture) + with self.assertRaises(ValueError): + measure.validate_report(fixture, 'debug', 0, 1) + + def test_report_rejects_pass_with_missing_evidence_or_false_window_coverage(self): + mutations = [lambda r: r['cases'][0].update(evidence_valid=False), + lambda r: r['cases'][0]['probes']['timer'].update(in_window_samples=0), + lambda r: r['cases'][0]['probes']['network']['samples'][0].update(in_window=False), + lambda r: r['cases'][0]['saves']['samples'][0].update(success=False)] + for mutate in mutations: + fixture = valid_report(); mutate(fixture) + with self.assertRaises(ValueError): + measure.validate_report(fixture, 'debug', 0, 1) + + def test_report_rejects_profile_mismatch(self): + with self.assertRaises(ValueError): + measure.validate_report({'schema':1,'status':'PASS','profile':'release','workers':0,'cases':[]}, 'debug', 0, 1) + + def test_report_rejects_missing_and_unbounded_cases(self): + for cases in ([], [{}]*11): + with self.assertRaises(ValueError): + measure.validate_report({'schema':1,'status':'PASS','profile':'debug','workers':0,'cases':cases}, 'debug', 0, 1) + + +if __name__ == '__main__': + unittest.main() From ca55126bf1bf0da79126352ee4cfa0f2d1a19e81 Mon Sep 17 00:00:00 2001 From: Mateusz Dalke <150788324+dalkedev@users.noreply.github.com> Date: Fri, 6 Nov 2026 20:51:01 +0000 Subject: [PATCH 2/8] ci: route branch archive measurements through registered dispatcher --- .github/workflows/archive-measurement.yml | 42 +++++++++++++++++++++ .github/workflows/checks.yml | 45 +---------------------- .github/workflows/har-compare-action.yml | 17 ++++++++- docs/ARCHIVE_RESPONSIVENESS.md | 13 ++++--- 4 files changed, 67 insertions(+), 50 deletions(-) create mode 100644 .github/workflows/archive-measurement.yml diff --git a/.github/workflows/archive-measurement.yml b/.github/workflows/archive-measurement.yml new file mode 100644 index 0000000..217c12f --- /dev/null +++ b/.github/workflows/archive-measurement.yml @@ -0,0 +1,42 @@ +name: Synthetic archive measurement +on: + workflow_dispatch: + workflow_call: +permissions: + contents: read +concurrency: + group: archive-measurement-${{ github.ref }} + cancel-in-progress: false +jobs: + archive-measurement: + name: Archive measurement ${{ matrix.os }} + runs-on: ${{ matrix.os }} + timeout-minutes: 45 + strategy: + fail-fast: false + matrix: + os: [ubuntu-22.04, windows-2022] + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + - uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 + with: + python-version: '3.12' + - uses: dtolnay/rust-toolchain@b725eda525362e7cf34af9a7243cac1e3f01a7ec + with: + toolchain: 1.99.1 + - name: Runner regressions + run: python -m unittest discover -s scripts/tests -p test_measure_archive.py + - name: Evidence detector regressions + run: cargo test --locked -p scope-core --lib diagnostics:: + - name: Measure fresh synthetic archives (debug and release separately) + run: python scripts/measure-archive.py --profiles debug release --samples 3 --workers 0 2 --output-dir .runtime/archive-measurement + - name: Upload numeric synthetic diagnostics only + if: always() + uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 + with: + name: archive-measurement-${{ matrix.os }}-${{ github.sha }} + path: .runtime/archive-measurement/measurement.json + if-no-files-found: error + retention-days: 14 diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.yml index cb96776..41ff35d 100644 --- a/.github/workflows/checks.yml +++ b/.github/workflows/checks.yml @@ -3,22 +3,13 @@ on: push: branches: [main, 'release/**'] pull_request: - workflow_dispatch: - inputs: - diagnostic: - description: Synthetic diagnostic to run (no release or deployment) - type: choice - options: [archive-measurement] - required: true - default: archive-measurement permissions: contents: read concurrency: - group: checks-${{ github.event_name }}-${{ github.ref }} + group: checks-${{ github.ref }} cancel-in-progress: true jobs: desktop: - if: github.event_name != 'workflow_dispatch' name: Check ${{ matrix.os }} timeout-minutes: 60 strategy: @@ -77,37 +68,3 @@ jobs: target/release/scope-mcp* if-no-files-found: error retention-days: 14 - - archive-measurement: - name: Archive measurement ${{ matrix.os }} - if: github.event_name == 'workflow_dispatch' && inputs.diagnostic == 'archive-measurement' - runs-on: ${{ matrix.os }} - timeout-minutes: 45 - strategy: - fail-fast: false - matrix: - os: [ubuntu-22.04, windows-2022] - steps: - - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 - with: - persist-credentials: false - - uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 - with: - python-version: '3.12' - - uses: dtolnay/rust-toolchain@b725eda525362e7cf34af9a7243cac1e3f01a7ec - with: - toolchain: 1.99.1 - - name: Runner regressions - run: python -m unittest discover -s scripts/tests -p test_measure_archive.py - - name: Evidence detector regressions - run: cargo test --locked -p scope-core --lib diagnostics:: - - name: Measure fresh synthetic archives (debug and release separately) - run: python scripts/measure-archive.py --profiles debug release --samples 3 --workers 0 2 --output-dir .runtime/archive-measurement - - name: Upload numeric synthetic diagnostics only - if: always() - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 - with: - name: archive-measurement-${{ matrix.os }}-${{ github.sha }} - path: .runtime/archive-measurement/measurement.json - if-no-files-found: error - retention-days: 14 diff --git a/.github/workflows/har-compare-action.yml b/.github/workflows/har-compare-action.yml index cd873f5..db4376b 100644 --- a/.github/workflows/har-compare-action.yml +++ b/.github/workflows/har-compare-action.yml @@ -12,16 +12,24 @@ on: - 'tools/har-compare/**' - '.github/workflows/har-compare-action.yml' workflow_dispatch: + inputs: + diagnostic: + description: Explicit diagnostic (archive measurement never runs the HAR consumer) + type: choice + options: [har-composite, archive-measurement] + required: false + default: har-composite permissions: contents: read concurrency: - group: har-composite-${{ github.ref }} + group: har-composite-${{ github.event_name }}-${{ inputs.diagnostic }}-${{ github.ref }} cancel-in-progress: true jobs: consumer: + if: github.event_name != 'workflow_dispatch' || inputs.diagnostic != 'archive-measurement' name: Composite ${{ matrix.scenario }} runs-on: ubuntu-22.04 timeout-minutes: 5 @@ -70,3 +78,10 @@ jobs: DEFAULT_OUTPUTS: ${{ toJSON(steps.default.outputs) }} DEFERRED_OUTPUTS: ${{ toJSON(steps.deferred.outputs) }} run: node '.scope action/tools/har-compare/action-test/integration-check.mjs' verify + + archive-measurement: + # Registered manual entry point while the dedicated workflow is branch-only. + if: github.event_name == 'workflow_dispatch' && inputs.diagnostic == 'archive-measurement' + uses: ./.github/workflows/archive-measurement.yml + permissions: + contents: read diff --git a/docs/ARCHIVE_RESPONSIVENESS.md b/docs/ARCHIVE_RESPONSIVENESS.md index 81d045d..8006fb7 100644 --- a/docs/ARCHIVE_RESPONSIVENESS.md +++ b/docs/ARCHIVE_RESPONSIVENESS.md @@ -17,15 +17,18 @@ python scripts/measure-archive.py --profiles debug release --samples 3 --workers The ignored unit-test harness and all observers are compiled only with `cfg(test)`; no diagnostic API or collector ships in the application. Normal CI runs deterministic detector regressions, not the ignored timing workload. -The existing Build and check workflow has a manual `archive-measurement` -diagnostic choice. Dispatch it explicitly against the reviewed branch: +The dedicated workflow supports manual dispatch and reuse. Before that new file +is registered on the default branch, the existing HAR composite workflow provides +an explicit `archive-measurement` manual choice and calls it locally. Dispatch +the registered entry point against the reviewed branch: ```sh -gh workflow run checks.yml --ref YOUR_BRANCH -f diagnostic=archive-measurement +gh workflow run har-compare-action.yml --ref YOUR_BRANCH -f diagnostic=archive-measurement ``` -Only the dedicated measurement jobs run on manual dispatch. Regular push/PR -checks keep their existing commands. Dispatch has a separate concurrency group, +Only dedicated measurement jobs run for this explicit choice; the HAR consumer +is skipped. Default HAR dispatch and regular push/PR checks keep their existing +commands. The checks/release workflows are unchanged. Dispatch has a separate concurrency group, contents-read permission, existing commit-pinned actions, no system-package installation or native-security changes, and a 45-minute job limit. Each runner exports one allowlisted numeric JSON artifact; compiler logs, archives and temporary CA keys From 00dcc6a5a4057142a5a75848a3645a25bbcc704b Mon Sep 17 00:00:00 2001 From: Mateusz Dalke <150788324+dalkedev@users.noreply.github.com> Date: Fri, 6 Nov 2026 20:51:46 +0000 Subject: [PATCH 3/8] ci: quote diagnostic command with a YAML block scalar --- .github/workflows/archive-measurement.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/archive-measurement.yml b/.github/workflows/archive-measurement.yml index 217c12f..c65c982 100644 --- a/.github/workflows/archive-measurement.yml +++ b/.github/workflows/archive-measurement.yml @@ -29,7 +29,8 @@ jobs: - name: Runner regressions run: python -m unittest discover -s scripts/tests -p test_measure_archive.py - name: Evidence detector regressions - run: cargo test --locked -p scope-core --lib diagnostics:: + run: | + cargo test --locked -p scope-core --lib diagnostics:: - name: Measure fresh synthetic archives (debug and release separately) run: python scripts/measure-archive.py --profiles debug release --samples 3 --workers 0 2 --output-dir .runtime/archive-measurement - name: Upload numeric synthetic diagnostics only From 04c78d202d61689a4c9444da120c375e0818a4fb Mon Sep 17 00:00:00 2001 From: Mateusz Dalke <150788324+dalkedev@users.noreply.github.com> Date: Fri, 6 Nov 2026 20:54:28 +0000 Subject: [PATCH 4/8] test: isolate platform metadata from subprocess control fixture --- scripts/tests/test_measure_archive.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/scripts/tests/test_measure_archive.py b/scripts/tests/test_measure_archive.py index 68c518d..0e8a161 100644 --- a/scripts/tests/test_measure_archive.py +++ b/scripts/tests/test_measure_archive.py @@ -110,6 +110,9 @@ def test_uncertain_cleanup_stops_all_subsequent_child_launches(self): uncertain = {'status':'TIMEOUT', 'returncode':-9, 'output':'', 'cleanup_uncertain':True} with patch.object(sys, 'argv', args), patch.dict(measure.os.environ, {}, clear=True), \ patch.object(measure.subprocess, 'check_output', side_effect=['a'*40, b'', 'rustc 1.99.1 (abcdef 2026-10-01)']), \ + patch.object(measure.platform, 'system', return_value='SyntheticOS'), \ + patch.object(measure.platform, 'machine', return_value='synthetic-arch'), \ + patch.object(measure.platform, 'python_version', return_value='3.12.10'), \ patch.object(measure, 'resource_limits', return_value={}), \ patch.object(measure, 'run_bounded', return_value=uncertain) as launch: self.assertEqual(measure.main(), 1) From 19aec4fc8ca63551c05a0380c157c5593f048efa Mon Sep 17 00:00:00 2001 From: Mateusz Dalke <150788324+dalkedev@users.noreply.github.com> Date: Fri, 6 Nov 2026 21:06:35 +0000 Subject: [PATCH 5/8] test: arm heartbeat after network probe readiness Preserve the actual Windows control failure and synchronize probe startup without changing measurement thresholds or production behavior. --- crates/scope-core/src/diagnostics/probes.rs | 17 +- docs/ARCHIVE_RESPONSIVENESS.md | 28 ++- .../archive-control-startup-2026-11-06.json | 212 ++++++++++++++++++ 3 files changed, 245 insertions(+), 12 deletions(-) create mode 100644 docs/benchmarks/archive-control-startup-2026-11-06.json diff --git a/crates/scope-core/src/diagnostics/probes.rs b/crates/scope-core/src/diagnostics/probes.rs index 17b808f..359ecae 100644 --- a/crates/scope-core/src/diagnostics/probes.rs +++ b/crates/scope-core/src/diagnostics/probes.rs @@ -157,6 +157,16 @@ impl Probes { } values }); + // Arm only after the independent network probe is ready. Otherwise + // readiness polling (notably Windows timer granularity) can leave an + // already-overdue first deadline outside the upcoming control window. + tokio::time::timeout(Duration::from_secs(3), async { + while !ready.load(Ordering::SeqCst) { + tokio::time::sleep(Duration::from_millis(1)).await; + } + }) + .await + .expect("loopback probe readiness failed"); let (timer_stop, timer_active) = (stop.clone(), active.clone()); let (tx, rx) = tokio::sync::oneshot::channel(); let timer = tokio::spawn(async move { @@ -188,13 +198,6 @@ impl Probes { values }); rx.await.unwrap(); - tokio::time::timeout(Duration::from_secs(3), async { - while !ready.load(Ordering::SeqCst) { - tokio::time::sleep(Duration::from_millis(1)).await; - } - }) - .await - .expect("loopback probe readiness failed"); active.store(true, Ordering::SeqCst); Self { epoch, diff --git a/docs/ARCHIVE_RESPONSIVENESS.md b/docs/ARCHIVE_RESPONSIVENESS.md index 8006fb7..18cce4e 100644 --- a/docs/ARCHIVE_RESPONSIVENESS.md +++ b/docs/ARCHIVE_RESPONSIVENESS.md @@ -94,12 +94,30 @@ if they were matched experiments. ## Result provenance -Hosted Linux: **NOT RUN** (awaiting reviewed dispatch). -Hosted Windows: **NOT RUN** (awaiting reviewed dispatch). +The first complete [measurement run 42292352293](https://github.com/dalkedev/scope/actions/runs/42292352293) +at `04c78d202d61689a4c9444da120c375e0818a4fb` passed Linux. Windows passed all +24 workload batches (32 correct clients/rows and 192 successful saves/revision +increments each), but its debug and release current-thread blocking controls +failed. This is a **FAIL of harness validation**, not archive evidence loss. + +Windows network readiness took approximately 24–26ms; the timer had already been +armed with its first deadline at approximately 11ms. After the intentional 300ms +block, that overdue deadline correctly fell outside the control window. The +network detector observed the block, while timer coverage was NOT RUN. The +[bounded numeric regression receipt](benchmarks/archive-control-startup-2026-11-06.json) +retains source/run/artifact provenance and both failed controls. No raw job logs, +archive rows or host identities are included. + +The harness now waits for independent network readiness **before** arming the +heartbeat. Window filtering, thresholds, workload and production behavior remain +unchanged. This fixes the observed readiness race; it does not promise +deterministic OS scheduling. Corrected-source hosted Linux/Windows validation is +**NOT RUN** until the next reviewed dispatch completes; the final result dataset +will be recorded here before this PR is ready. + Local debug smoke: all four HTTP/TLS × current-thread/two-worker batches passed -with one sample per case, including both detector controls. This is a harness -smoke check, not comparative performance evidence. Hosted result artifacts and -exact source/run provenance will replace the pending entries before delivery. +with one sample per case, including the blocking and persisted-evidence controls. +This is a harness smoke check, not comparative performance evidence. GUI/Android, real captures, external endpoints, sustained/large-body workloads, fsync counts, isolated storage latency and production performance: **NOT RUN**. diff --git a/docs/benchmarks/archive-control-startup-2026-11-06.json b/docs/benchmarks/archive-control-startup-2026-11-06.json new file mode 100644 index 0000000..2506f75 --- /dev/null +++ b/docs/benchmarks/archive-control-startup-2026-11-06.json @@ -0,0 +1,212 @@ +{ + "schema": 1, + "status": "FAIL", + "scope": "Harness positive-control startup validation; workload evidence itself passed.", + "source_commit": "04c78d202d61689a4c9444da120c375e0818a4fb", + "run_id": 42292352293, + "run_url": "https://github.com/dalkedev/scope/actions/runs/42292352293", + "artifact_id": 13541075422, + "artifact_zip_sha256": "3bc89c7248ba9be274dc88d4ecf2e980020ec24cbd7d3c1419d11fe9e204d9fa", + "original_measurement_json_sha256": "2133fefd463631079a4d4d26fdc15d19441b20d27856984d9327b56fe8db3e39", + "runner_image": { + "GITHUB_RUN_ID": "42292352293", + "GITHUB_RUN_ATTEMPT": "1", + "ImageOS": null, + "ImageVersion": null + }, + "os": "Windows", + "compiler": "rustc 1.99.1 (58cf8f9c3 2026-10-13)", + "workload_batches_passed": 24, + "clients_per_batch": 32, + "persisted_rows_per_batch": 32, + "save_statements_per_batch": 192, + "failed_controls": [ + { + "profile": "debug", + "workers": 0, + "detector_threshold_ms": 100, + "injected_block_ms": 300, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 290787000, + 299000, + 289700 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 290787000, + "end_ns": 326666900, + "in_window": true, + "scheduled_ns": null, + "start_ns": 35879900, + "success": true + }, + { + "elapsed_ns": 299000, + "end_ns": 337163400, + "in_window": false, + "scheduled_ns": null, + "start_ns": 336864400, + "success": true + }, + { + "elapsed_ns": 289700, + "end_ns": 347593300, + "in_window": false, + "scheduled_ns": null, + "start_ns": 347303600, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 314690000, + 5209700, + 4115100, + 6188900 + ], + "failures": 0, + "in_window_samples": 0, + "missed_periods": 31, + "samples": [ + { + "elapsed_ns": 314690000, + "end_ns": 326360300, + "in_window": false, + "scheduled_ns": 11670300, + "start_ns": 326360300, + "success": true + }, + { + "elapsed_ns": 5209700, + "end_ns": 336880000, + "in_window": false, + "scheduled_ns": 331670300, + "start_ns": 336880000, + "success": true + }, + { + "elapsed_ns": 4115100, + "end_ns": 345785400, + "in_window": false, + "scheduled_ns": 341670300, + "start_ns": 345785400, + "success": true + }, + { + "elapsed_ns": 6188900, + "end_ns": 357859200, + "in_window": false, + "scheduled_ns": 351670300, + "start_ns": 357859200, + "success": true + } + ], + "window_status": "NOTRUN" + }, + "window_end_ns": 326279300, + "window_start_ns": 25712800 + }, + "status": "FAIL" + }, + { + "profile": "release", + "workers": 0, + "detector_threshold_ms": 100, + "injected_block_ms": 300, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 290187900, + 246800, + 213600 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 290187900, + "end_ns": 324416600, + "in_window": true, + "scheduled_ns": null, + "start_ns": 34228700, + "success": true + }, + { + "elapsed_ns": 246800, + "end_ns": 334847500, + "in_window": false, + "scheduled_ns": null, + "start_ns": 334600700, + "success": true + }, + { + "elapsed_ns": 213600, + "end_ns": 345193100, + "in_window": false, + "scheduled_ns": null, + "start_ns": 344979500, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 313290900, + 3698200, + 4100300 + ], + "failures": 0, + "in_window_samples": 0, + "missed_periods": 31, + "samples": [ + { + "elapsed_ns": 313290900, + "end_ns": 324197900, + "in_window": false, + "scheduled_ns": 10907000, + "start_ns": 324197900, + "success": true + }, + { + "elapsed_ns": 3698200, + "end_ns": 334605200, + "in_window": false, + "scheduled_ns": 330907000, + "start_ns": 334605200, + "success": true + }, + { + "elapsed_ns": 4100300, + "end_ns": 345007300, + "in_window": false, + "scheduled_ns": 340907000, + "start_ns": 345007300, + "success": true + } + ], + "window_status": "NOTRUN" + }, + "window_end_ns": 324186000, + "window_start_ns": 23800900 + }, + "status": "FAIL" + } + ] +} From 1f6c8dd9462fe7633a9c3039b6a906ced96cbdcb Mon Sep 17 00:00:00 2001 From: Mateusz Dalke <150788324+dalkedev@users.noreply.github.com> Date: Fri, 6 Nov 2026 21:17:39 +0000 Subject: [PATCH 6/8] docs: record reviewed Linux and Windows archive measurements Preserve exact hosted provenance, numeric samples and descriptive distributions. Document unmeasured limits and bounded admission/persistence requirements without a production rewrite. --- docs/ARCHIVE_RESPONSIVENESS.md | 108 +- ...chive-responsiveness-2026-11-06-linux.json | 39163 ++++++++++++++++ ...ive-responsiveness-2026-11-06-summary.json | 1337 + ...ive-responsiveness-2026-11-06-windows.json | 39109 +++++++++++++++ .../plans/2026-11-06-archive-measurement.md | 11 +- 5 files changed, 79719 insertions(+), 9 deletions(-) create mode 100644 docs/benchmarks/archive-responsiveness-2026-11-06-linux.json create mode 100644 docs/benchmarks/archive-responsiveness-2026-11-06-summary.json create mode 100644 docs/benchmarks/archive-responsiveness-2026-11-06-windows.json diff --git a/docs/ARCHIVE_RESPONSIVENESS.md b/docs/ARCHIVE_RESPONSIVENESS.md index 18cce4e..b62843b 100644 --- a/docs/ARCHIVE_RESPONSIVENESS.md +++ b/docs/ARCHIVE_RESPONSIVENESS.md @@ -4,7 +4,9 @@ This investigates [#28](https://github.com/dalkedev/scope/issues/28) against Scope 1.2.2. It does not change production scheduling, SQLite settings, capture limits, response ordering, native security settings or existing test deadlines. Six `Engine::save` calls per successful mock exchange mean 192 upserts for 32 -requests. That is **not** a count of disk flushes. +requests. That is **not** a count of disk flushes. The corrected hosted Linux and +Windows dataset below passes all 48 synthetic workload batches and every required +positive control; it does not establish a production performance improvement. ## Reproduce @@ -43,6 +45,9 @@ batches, each using a fresh temporary file-backed archive and client pool. Thirty-two barrier-released logical requests use shared reqwest client clones, HTTP/1.1, a 30-second client deadline and 60-second cooperative batch deadline. These are logical clients, not a claim of 32 simultaneous network connections. +In JSON, workers=0 identifies current-thread execution on the calling thread; +workers=2 selects two Tokio worker threads. Both runtimes cap the blocking pool +at two threads and use one separate OS network-probe thread. URLs target only loopback; three real rules rewrite the empty request, mock a 201 response, and rewrite that response. TLS uses actual CONNECT interception and the newly generated CA. Nothing is sent to an external origin. @@ -92,7 +97,93 @@ configuration is not inspected; clean hosted runs are the controlled profile reference. Do not compare debug and release or differently constrained hosts as if they were matched experiments. -## Result provenance +## Corrected hosted results and provenance + +**PASS:** [run 42293997874](https://github.com/dalkedev/scope/actions/runs/42293997874), +measured source `19aec4fc8ca63551c05a0380c157c5593f048efa`, clean checkouts on +`ubuntu-22.04` and `windows-2022`, Rust 1.99.1, Python 3.12.16 on Linux / +3.12.10 on Windows, four logical CPUs and two Cargo build jobs on each runner. +Linux affinity exposed four CPUs; +Windows affinity, memory/I/O quotas, filesystem type and peak RSS are NOT RUN. +Unknown cgroup limits remain null, not assumed unlimited. Linux image version is +`20261101.347.1`; Windows image version is NOT RUN (not captured in the report). +Its selected label is `windows-2022`. +Exact per-platform metadata and SQLite compile options remain in the raw datasets. + +All **48/48** workload batches passed: three samples for each OS × profile × +runtime × transport combination, 1,536 correct completed clients and persisted +rows, and 9,216 successful measured save statements/revision increments. Each +batch independently verified all rule evidence, original snapshots, request +pairing and reopened IDs. All 48 rule-corruption and 48 independent row-loss +controls detected the deliberate corruption, with baseline restoration checked. +The four current-thread timer/network blocking controls passed (debug/release on +both platforms); two-worker blocking controls remain intentionally NOT RUN. +No sample overflow, probe failures in workload windows, cooperative timeout or +observed client/batch deadline violation occurred. + +Both platforms reported SQLite 3.51.1, WAL, synchronous=2 (FULL), busy_timeout=5000ms, +page_size=4096, cache_size=-2000 and wal_autocheckpoint=1000. The harness did not +change these values. Every batch has both timer and network window coverage; +raw reports retain all sample timestamps and explicit coverage states. + +- [Linux raw numeric report](benchmarks/archive-responsiveness-2026-11-06-linux.json) +- [Windows raw numeric report](benchmarks/archive-responsiveness-2026-11-06-windows.json) +- [Derived distributions, source hashes and artifact receipts](benchmarks/archive-responsiveness-2026-11-06-summary.json) + +The downloadable ZIP SHA-256 values were matched to GitHub's API +artifact digests before extracting the sole allowlisted `measurement.json` file. +The summary records artifact IDs/digests and raw JSON SHA-256 values. All runtime +reports passed the strict schema validator, source/clean-tree/run/attempt/sample +identity checks and exact evidence counts. Independent review recalculated all +16 groups and every displayed table cell. The final PR may add documentation; +its measurement-source hashes must continue to match this measured commit. + +### Descriptive timings (milliseconds) + +Each row has three batches. Batch is median (min–max). Client p95 pools the 96 +client durations within that row using nearest rank. Phase columns are medians +of each batch's **sum of 192 saves**. Timer and echo columns are maxima of samples +whose deadlines/attempts cover the workload window. These are small descriptive +samples, without confidence intervals or significance claims. Do not pool profiles, +add overlapping mutex/statement sums, or treat OS/hardware as a controlled single +variable. Raw/derived files retain every sample, probe count and shutdown duration. + +| OS | Profile | Tokio workers | Transport | Batch median (range) | Client p95 | Σ serialize | Σ mutex wait | Σ SQL | Max timer lag | Max echo RTT | +| --- | --- | --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | +| Linux | debug | current | HTTP | 121.56 (110.79–123.57) | 121.12 | 8.48 | 0.04 | 89.76 | 111.69 | 111.41 | +| Linux | debug | current | TLS | 198.53 (196.86–225.39) | 201.41 | 8.63 | 0.05 | 82.26 | 96.63 | 85.47 | +| Linux | debug | 2 | HTTP | 85.19 (84.76–87.92) | 85.55 | 9.34 | 56.22 | 75.20 | 45.54 | 74.45 | +| Linux | debug | 2 | TLS | 146.34 (140.94–193.33) | 180.68 | 9.09 | 50.86 | 79.14 | 62.20 | 53.21 | +| Linux | release | current | HTTP | 74.94 (69.67–82.82) | 82.27 | 0.60 | 0.01 | 68.32 | 72.61 | 74.38 | +| Linux | release | current | TLS | 131.55 (121.76–157.09) | 125.68 | 0.62 | 0.01 | 68.54 | 71.97 | 76.54 | +| Linux | release | 2 | HTTP | 72.54 (71.52–75.02) | 73.88 | 0.77 | 65.22 | 68.05 | 48.92 | 63.89 | +| Linux | release | 2 | TLS | 118.56 (116.03–153.06) | 143.52 | 0.70 | 60.80 | 69.67 | 54.57 | 35.75 | +| Windows | debug | current | HTTP | 673.30 (651.91–753.71) | 750.43 | 8.97 | 0.04 | 636.30 | 731.97 | 731.12 | +| Windows | debug | current | TLS | 749.69 (725.40–851.98) | 849.28 | 8.75 | 0.04 | 613.30 | 670.23 | 666.42 | +| Windows | debug | 2 | HTTP | 648.30 (643.08–721.82) | 717.12 | 9.81 | 606.98 | 637.76 | 407.40 | 629.28 | +| Windows | debug | 2 | TLS | 717.35 (675.94–723.68) | 720.50 | 9.56 | 562.43 | 623.42 | 580.99 | 533.91 | +| Windows | release | current | HTTP | 600.55 (575.29–606.54) | 605.63 | 1.00 | 0.01 | 586.73 | 596.11 | 595.68 | +| Windows | release | current | TLS | 599.64 (573.69–691.05) | 689.65 | 1.01 | 0.01 | 559.26 | 568.55 | 542.86 | +| Windows | release | 2 | HTTP | 563.19 (561.49–573.37) | 569.16 | 1.10 | 545.89 | 555.80 | 559.00 | 562.33 | +| Windows | release | 2 | TLS | 578.15 (570.08–624.50) | 583.99 | 1.11 | 534.21 | 561.51 | 409.62 | 416.58 | + +The current-thread profiles show delayed timer wakes and loopback echo servicing +during these bursts. In these samples the synchronous SQL phase occupies much +of batch wall time; two-worker runs also show connection-mutex waiting. These +observations justify a controlled blocking-writer experiment, not a claim that +SQLite disk latency caused the earlier Windows timeouts. SQL time includes +internal locks, triggers, autocommit/checkpoint work and OS effects. TLS adds +other scheduling/cryptographic work; no isolated storage or zero-write baseline +was measured. The historical 29-client timeout failure was **not reproduced**. +The four intentional blocking controls validate detection of known executor +stalls; they do not attribute real-workload lag to one underlying cause. + +No production rewrite is implemented. The next design should first isolate +scheduling while preserving every persistence barrier, then measure it against +this harness with matched profiles. The size/admission/finalization prerequisites +below remain unresolved; batching is a separate later experiment. + +## Preserved control-startup regression The first complete [measurement run 42292352293](https://github.com/dalkedev/scope/actions/runs/42292352293) at `04c78d202d61689a4c9444da120c375e0818a4fb` passed Linux. Windows passed all @@ -111,9 +202,8 @@ archive rows or host identities are included. The harness now waits for independent network readiness **before** arming the heartbeat. Window filtering, thresholds, workload and production behavior remain unchanged. This fixes the observed readiness race; it does not promise -deterministic OS scheduling. Corrected-source hosted Linux/Windows validation is -**NOT RUN** until the next reviewed dispatch completes; the final result dataset -will be recorded here before this PR is ready. +deterministic OS scheduling. The corrected-source hosted dataset above passes +the unchanged controls on both platforms; the original failed report remains preserved for regression evidence. Local debug smoke: all four HTTP/TLS × current-thread/two-worker batches passed with one sample per case, including the blocking and persisted-evidence controls. @@ -141,6 +231,14 @@ fallback is permitted. Reserve finalization capacity before admitting a capture so overload cannot deadlock its terminal error write. Resource reservations are released only after acknowledgement/finalization, not when a waiting future drops. +Also bound capture owners and admission waiters separately: a candidate envelope +is 32 admitted captures and at most eight pending admissions, with finite waiting +deadlines. Reject excess admission explicitly before forwarding or buffering a +body; do not create an unbounded task list waiting for queue capacity. Transport +connections/handshakes need their own finite limits. These limits and rejection +semantics require protocol/error-finalization tests before implementation; queue +slots alone do not bound the whole capture process. + This is a proposal, not a claim that eight slots or 128MiB is optimal. The existing 16MiB body limit does not bound an entire JSON exchange with headers, encoding and original snapshots. Before implementation, establish an exact diff --git a/docs/benchmarks/archive-responsiveness-2026-11-06-linux.json b/docs/benchmarks/archive-responsiveness-2026-11-06-linux.json new file mode 100644 index 0000000..0f2cee2 --- /dev/null +++ b/docs/benchmarks/archive-responsiveness-2026-11-06-linux.json @@ -0,0 +1,39163 @@ +{ + "schema": 1, + "status": "PASS", + "metadata": { + "source_commit": "19aec4fc8ca63551c05a0380c157c5593f048efa", + "source_dirty": false, + "compiler": "rustc 1.99.1 (58cf8f9c3 2026-10-13)", + "os": "Linux", + "architecture": "x86_64", + "python": "3.12.16", + "hosted": { + "GITHUB_RUN_ID": "42293997874", + "GITHUB_RUN_ATTEMPT": "1", + "ImageOS": "ubuntu22", + "ImageVersion": "20261101.347.1" + }, + "resources": { + "logical_cpus": 4, + "affinity_cpus": 4, + "cgroup_memory_max_bytes": null, + "cgroup_cpu_quota_us": null, + "cgroup_cpu_period_us": null, + "peak_child_rss": "NOTRUN", + "filesystem_type": "NOTRUN", + "io_quota": "NOTRUN" + }, + "build_jobs": 2, + "profiles": [ + "debug", + "release" + ], + "workers": [ + 0, + 2 + ], + "samples_per_transport": 3, + "build_hard_timeout_s": 600, + "child_hard_timeout_s": 420, + "overall_budget_s": 1800, + "optimization": { + "debug": "repository profile: opt-level=0,debug=1", + "release": "repository profile: opt-level=3,lto=thin,strip=true" + }, + "profile_limits": "environment flag/profile/wrapper overrides rejected; user Cargo configuration is not inspected; hosted jobs use clean checkout and toolchain", + "storage": "OS temporary directory; fresh file-backed SQLite archive per case; path omitted", + "unavailable_resource_fields": "null means NOTRUN or not exposed by this platform" + }, + "results": [ + { + "profile": "debug", + "workers": 0, + "status": "PASS", + "reason": null, + "report": { + "cases": [ + { + "batch_elapsed_ns": 121559741, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 119630660, + 119405440, + 119238629, + 119100392, + 118957125, + 118805883, + 118660613, + 118501476, + 118350114, + 118212198, + 118068720, + 117931796, + 117758683, + 117624573, + 117515511, + 117393523, + 117260325, + 117098824, + 116958493, + 116812331, + 116675566, + 116532629, + 116366139, + 116227361, + 116085657, + 115942951, + 115790436, + 115733481, + 115572982, + 115435125, + 115249019, + 115099941 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 694874, + 99659336, + 219599, + 181538 + ], + "failures": 0, + "in_window_samples": 2, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 694874, + "end_ns": 11111810, + "in_window": true, + "scheduled_ns": null, + "start_ns": 10416936, + "success": true + }, + { + "elapsed_ns": 99659336, + "end_ns": 120848203, + "in_window": true, + "scheduled_ns": null, + "start_ns": 21188867, + "success": true + }, + { + "elapsed_ns": 219599, + "end_ns": 131143647, + "in_window": false, + "scheduled_ns": null, + "start_ns": 130924048, + "success": true + }, + { + "elapsed_ns": 181538, + "end_ns": 141400420, + "in_window": false, + "scheduled_ns": null, + "start_ns": 141218882, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 109689599, + 1529736, + 1819720, + 1076701, + 1188990 + ], + "failures": 0, + "in_window_samples": 2, + "missed_periods": 10, + "samples": [ + { + "elapsed_ns": 109689599, + "end_ns": 122150101, + "in_window": true, + "scheduled_ns": 12460502, + "start_ns": 122150101, + "success": true + }, + { + "elapsed_ns": 1529736, + "end_ns": 123990238, + "in_window": true, + "scheduled_ns": 122460502, + "start_ns": 123990238, + "success": true + }, + { + "elapsed_ns": 1819720, + "end_ns": 134280222, + "in_window": false, + "scheduled_ns": 132460502, + "start_ns": 134280222, + "success": true + }, + { + "elapsed_ns": 1076701, + "end_ns": 143537203, + "in_window": false, + "scheduled_ns": 142460502, + "start_ns": 143537203, + "success": true + }, + { + "elapsed_ns": 1188990, + "end_ns": 153649492, + "in_window": false, + "scheduled_ns": 152460502, + "start_ns": 153649492, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 124035512, + "window_start_ns": 2475771 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 0, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 360, + "serialization_ns": 27401, + "serialized_bytes": 612, + "statement_ns": 559502, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 27411, + "serialized_bytes": 612, + "statement_ns": 469735, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 44192, + "serialized_bytes": 1038, + "statement_ns": 521270, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 46226, + "serialized_bytes": 1077, + "statement_ns": 440640, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 46216, + "serialized_bytes": 1085, + "statement_ns": 432466, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 53901, + "serialized_bytes": 1300, + "statement_ns": 481918, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 26339, + "serialized_bytes": 612, + "statement_ns": 449657, + "success": true + }, + { + "mutex_wait_ns": 130, + "serialization_ns": 26850, + "serialized_bytes": 612, + "statement_ns": 396098, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 43190, + "serialized_bytes": 1038, + "statement_ns": 588406, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 45545, + "serialized_bytes": 1077, + "statement_ns": 492717, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 46226, + "serialized_bytes": 1085, + "statement_ns": 408711, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 53851, + "serialized_bytes": 1300, + "statement_ns": 485835, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 26800, + "serialized_bytes": 612, + "statement_ns": 404383, + "success": true + }, + { + "mutex_wait_ns": 140, + "serialization_ns": 27040, + "serialized_bytes": 612, + "statement_ns": 412078, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 43781, + "serialized_bytes": 1038, + "statement_ns": 420593, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 47900, + "serialized_bytes": 1077, + "statement_ns": 400977, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48781, + "serialized_bytes": 1085, + "statement_ns": 395888, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 56746, + "serialized_bytes": 1300, + "statement_ns": 444197, + "success": true + }, + { + "mutex_wait_ns": 410, + "serialization_ns": 29626, + "serialized_bytes": 610, + "statement_ns": 465638, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 29956, + "serialized_bytes": 610, + "statement_ns": 367995, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 48641, + "serialized_bytes": 1034, + "statement_ns": 376481, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 47900, + "serialized_bytes": 1073, + "statement_ns": 460838, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 49773, + "serialized_bytes": 1081, + "statement_ns": 560914, + "success": true + }, + { + "mutex_wait_ns": 230, + "serialization_ns": 60032, + "serialized_bytes": 1296, + "statement_ns": 434600, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 29134, + "serialized_bytes": 610, + "statement_ns": 504148, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 29616, + "serialized_bytes": 610, + "statement_ns": 365401, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 48290, + "serialized_bytes": 1034, + "statement_ns": 405034, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 50785, + "serialized_bytes": 1073, + "statement_ns": 436273, + "success": true + }, + { + "mutex_wait_ns": 161, + "serialization_ns": 51055, + "serialized_bytes": 1081, + "statement_ns": 398742, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 60052, + "serialized_bytes": 1296, + "statement_ns": 422838, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 29184, + "serialized_bytes": 612, + "statement_ns": 707728, + "success": true + }, + { + "mutex_wait_ns": 161, + "serialization_ns": 26960, + "serialized_bytes": 612, + "statement_ns": 437605, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 43250, + "serialized_bytes": 1038, + "statement_ns": 442834, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 45986, + "serialized_bytes": 1077, + "statement_ns": 397210, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 46777, + "serialized_bytes": 1085, + "statement_ns": 452172, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 54371, + "serialized_bytes": 1300, + "statement_ns": 425864, + "success": true + }, + { + "mutex_wait_ns": 381, + "serialization_ns": 27100, + "serialized_bytes": 612, + "statement_ns": 515259, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 28063, + "serialized_bytes": 612, + "statement_ns": 451210, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 45976, + "serialized_bytes": 1038, + "statement_ns": 409212, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 47899, + "serialized_bytes": 1077, + "statement_ns": 382061, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 48610, + "serialized_bytes": 1085, + "statement_ns": 473522, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 60282, + "serialized_bytes": 1300, + "statement_ns": 428839, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 29194, + "serialized_bytes": 612, + "statement_ns": 397200, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 29495, + "serialized_bytes": 612, + "statement_ns": 475095, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 48651, + "serialized_bytes": 1038, + "statement_ns": 368486, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 47919, + "serialized_bytes": 1077, + "statement_ns": 430492, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 48710, + "serialized_bytes": 1085, + "statement_ns": 423439, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 56575, + "serialized_bytes": 1300, + "statement_ns": 408210, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 27592, + "serialized_bytes": 612, + "statement_ns": 471878, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 29615, + "serialized_bytes": 612, + "statement_ns": 422026, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 49242, + "serialized_bytes": 1038, + "statement_ns": 534133, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 56525, + "serialized_bytes": 1077, + "statement_ns": 3548158, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 66384, + "serialized_bytes": 1085, + "statement_ns": 664487, + "success": true + }, + { + "mutex_wait_ns": 240, + "serialization_ns": 72014, + "serialized_bytes": 1300, + "statement_ns": 641435, + "success": true + }, + { + "mutex_wait_ns": 381, + "serialization_ns": 34043, + "serialized_bytes": 610, + "statement_ns": 543573, + "success": true + }, + { + "mutex_wait_ns": 151, + "serialization_ns": 32119, + "serialized_bytes": 610, + "statement_ns": 433898, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 52488, + "serialized_bytes": 1034, + "statement_ns": 523575, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 48280, + "serialized_bytes": 1073, + "statement_ns": 411146, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 51316, + "serialized_bytes": 1081, + "statement_ns": 443676, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 60272, + "serialized_bytes": 1296, + "statement_ns": 488449, + "success": true + }, + { + "mutex_wait_ns": 350, + "serialization_ns": 27952, + "serialized_bytes": 610, + "statement_ns": 482689, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 28523, + "serialized_bytes": 610, + "statement_ns": 364178, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 46848, + "serialized_bytes": 1034, + "statement_ns": 441472, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 48190, + "serialized_bytes": 1073, + "statement_ns": 405876, + "success": true + }, + { + "mutex_wait_ns": 151, + "serialization_ns": 51545, + "serialized_bytes": 1081, + "statement_ns": 390637, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 60242, + "serialized_bytes": 1296, + "statement_ns": 453675, + "success": true + }, + { + "mutex_wait_ns": 420, + "serialization_ns": 63438, + "serialized_bytes": 610, + "statement_ns": 494792, + "success": true + }, + { + "mutex_wait_ns": 150, + "serialization_ns": 28363, + "serialized_bytes": 610, + "statement_ns": 400065, + "success": true + }, + { + "mutex_wait_ns": 310, + "serialization_ns": 50655, + "serialized_bytes": 1034, + "statement_ns": 396649, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 46006, + "serialized_bytes": 1073, + "statement_ns": 490373, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 46777, + "serialized_bytes": 1081, + "statement_ns": 431875, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 57427, + "serialized_bytes": 1296, + "statement_ns": 373575, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 27932, + "serialized_bytes": 612, + "statement_ns": 461610, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 28553, + "serialized_bytes": 612, + "statement_ns": 359289, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 46306, + "serialized_bytes": 1038, + "statement_ns": 474072, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 46286, + "serialized_bytes": 1077, + "statement_ns": 496785, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 46967, + "serialized_bytes": 1085, + "statement_ns": 389225, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 56675, + "serialized_bytes": 1300, + "statement_ns": 467671, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 28763, + "serialized_bytes": 612, + "statement_ns": 471478, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 28163, + "serialized_bytes": 612, + "statement_ns": 410264, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 46086, + "serialized_bytes": 1038, + "statement_ns": 417427, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 46416, + "serialized_bytes": 1077, + "statement_ns": 536419, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 47008, + "serialized_bytes": 1085, + "statement_ns": 416005, + "success": true + }, + { + "mutex_wait_ns": 311, + "serialization_ns": 85589, + "serialized_bytes": 1300, + "statement_ns": 390758, + "success": true + }, + { + "mutex_wait_ns": 370, + "serialization_ns": 27983, + "serialized_bytes": 612, + "statement_ns": 474674, + "success": true + }, + { + "mutex_wait_ns": 150, + "serialization_ns": 28543, + "serialized_bytes": 612, + "statement_ns": 462702, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 43921, + "serialized_bytes": 1038, + "statement_ns": 410274, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 46406, + "serialized_bytes": 1077, + "statement_ns": 424931, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 48490, + "serialized_bytes": 1085, + "statement_ns": 461720, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 56646, + "serialized_bytes": 1300, + "statement_ns": 468202, + "success": true + }, + { + "mutex_wait_ns": 350, + "serialization_ns": 32812, + "serialized_bytes": 610, + "statement_ns": 486737, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 28423, + "serialized_bytes": 610, + "statement_ns": 445730, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 43862, + "serialized_bytes": 1034, + "statement_ns": 448536, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 45935, + "serialized_bytes": 1073, + "statement_ns": 425262, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 46236, + "serialized_bytes": 1081, + "statement_ns": 495062, + "success": true + }, + { + "mutex_wait_ns": 240, + "serialization_ns": 53900, + "serialized_bytes": 1296, + "statement_ns": 394215, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 27721, + "serialized_bytes": 612, + "statement_ns": 452934, + "success": true + }, + { + "mutex_wait_ns": 140, + "serialization_ns": 28393, + "serialized_bytes": 612, + "statement_ns": 461640, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 45905, + "serialized_bytes": 1038, + "statement_ns": 392040, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 47658, + "serialized_bytes": 1077, + "statement_ns": 403211, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 48420, + "serialized_bytes": 1085, + "statement_ns": 382773, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 59922, + "serialized_bytes": 1300, + "statement_ns": 525669, + "success": true + }, + { + "mutex_wait_ns": 360, + "serialization_ns": 27281, + "serialized_bytes": 612, + "statement_ns": 417518, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 33462, + "serialized_bytes": 612, + "statement_ns": 642026, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 46106, + "serialized_bytes": 1038, + "statement_ns": 702178, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 48220, + "serialized_bytes": 1077, + "statement_ns": 515280, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 51366, + "serialized_bytes": 1085, + "statement_ns": 451662, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 60022, + "serialized_bytes": 1300, + "statement_ns": 480204, + "success": true + }, + { + "mutex_wait_ns": 341, + "serialization_ns": 29164, + "serialized_bytes": 612, + "statement_ns": 466749, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 29925, + "serialized_bytes": 612, + "statement_ns": 402911, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 45565, + "serialized_bytes": 1038, + "statement_ns": 461800, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 47628, + "serialized_bytes": 1077, + "statement_ns": 386339, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 48370, + "serialized_bytes": 1085, + "statement_ns": 407569, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 56495, + "serialized_bytes": 1300, + "statement_ns": 495713, + "success": true + }, + { + "mutex_wait_ns": 381, + "serialization_ns": 28072, + "serialized_bytes": 612, + "statement_ns": 423839, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 28363, + "serialized_bytes": 612, + "statement_ns": 405194, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 45865, + "serialized_bytes": 1038, + "statement_ns": 444157, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46216, + "serialized_bytes": 1077, + "statement_ns": 483741, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 46707, + "serialized_bytes": 1085, + "statement_ns": 435130, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 57126, + "serialized_bytes": 1300, + "statement_ns": 413891, + "success": true + }, + { + "mutex_wait_ns": 340, + "serialization_ns": 28343, + "serialized_bytes": 612, + "statement_ns": 543262, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 28433, + "serialized_bytes": 612, + "statement_ns": 369248, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 45615, + "serialized_bytes": 1038, + "statement_ns": 396288, + "success": true + }, + { + "mutex_wait_ns": 301, + "serialization_ns": 79758, + "serialized_bytes": 1077, + "statement_ns": 459606, + "success": true + }, + { + "mutex_wait_ns": 161, + "serialization_ns": 48380, + "serialized_bytes": 1085, + "statement_ns": 412688, + "success": true + }, + { + "mutex_wait_ns": 240, + "serialization_ns": 62176, + "serialized_bytes": 1300, + "statement_ns": 448015, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 28002, + "serialized_bytes": 610, + "statement_ns": 529265, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 28433, + "serialized_bytes": 610, + "statement_ns": 363828, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 45716, + "serialized_bytes": 1034, + "statement_ns": 403061, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 48160, + "serialized_bytes": 1073, + "statement_ns": 438387, + "success": true + }, + { + "mutex_wait_ns": 150, + "serialization_ns": 46456, + "serialized_bytes": 1081, + "statement_ns": 369970, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 54321, + "serialized_bytes": 1296, + "statement_ns": 373566, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 26950, + "serialized_bytes": 612, + "statement_ns": 565303, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 27451, + "serialized_bytes": 612, + "statement_ns": 476197, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 43821, + "serialized_bytes": 1038, + "statement_ns": 488630, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 46266, + "serialized_bytes": 1077, + "statement_ns": 421525, + "success": true + }, + { + "mutex_wait_ns": 250, + "serialization_ns": 78957, + "serialized_bytes": 1085, + "statement_ns": 523185, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 56996, + "serialized_bytes": 1300, + "statement_ns": 456440, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 27962, + "serialized_bytes": 612, + "statement_ns": 458313, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 29835, + "serialized_bytes": 612, + "statement_ns": 489592, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 48471, + "serialized_bytes": 1038, + "statement_ns": 461469, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 50764, + "serialized_bytes": 1077, + "statement_ns": 448826, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 51325, + "serialized_bytes": 1085, + "statement_ns": 455308, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 56495, + "serialized_bytes": 1300, + "statement_ns": 458033, + "success": true + }, + { + "mutex_wait_ns": 341, + "serialization_ns": 27872, + "serialized_bytes": 612, + "statement_ns": 448505, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 28684, + "serialized_bytes": 612, + "statement_ns": 441823, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 45525, + "serialized_bytes": 1038, + "statement_ns": 407630, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 45876, + "serialized_bytes": 1077, + "statement_ns": 378946, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 46446, + "serialized_bytes": 1085, + "statement_ns": 422366, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 56465, + "serialized_bytes": 1300, + "statement_ns": 488479, + "success": true + }, + { + "mutex_wait_ns": 341, + "serialization_ns": 26900, + "serialized_bytes": 610, + "statement_ns": 411556, + "success": true + }, + { + "mutex_wait_ns": 150, + "serialization_ns": 27591, + "serialized_bytes": 610, + "statement_ns": 401528, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 45525, + "serialized_bytes": 1034, + "statement_ns": 463533, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 47779, + "serialized_bytes": 1073, + "statement_ns": 397870, + "success": true + }, + { + "mutex_wait_ns": 151, + "serialization_ns": 49973, + "serialized_bytes": 1081, + "statement_ns": 392431, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 56856, + "serialized_bytes": 1296, + "statement_ns": 485685, + "success": true + }, + { + "mutex_wait_ns": 341, + "serialization_ns": 27210, + "serialized_bytes": 612, + "statement_ns": 496054, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 27592, + "serialized_bytes": 612, + "statement_ns": 409112, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 44122, + "serialized_bytes": 1038, + "statement_ns": 501394, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 46226, + "serialized_bytes": 1077, + "statement_ns": 381731, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 48620, + "serialized_bytes": 1085, + "statement_ns": 501924, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 56635, + "serialized_bytes": 1300, + "statement_ns": 723388, + "success": true + }, + { + "mutex_wait_ns": 1343, + "serialization_ns": 29194, + "serialized_bytes": 612, + "statement_ns": 506673, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 30367, + "serialized_bytes": 612, + "statement_ns": 408812, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 48581, + "serialized_bytes": 1038, + "statement_ns": 375991, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 45785, + "serialized_bytes": 1077, + "statement_ns": 519257, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46837, + "serialized_bytes": 1085, + "statement_ns": 395257, + "success": true + }, + { + "mutex_wait_ns": 241, + "serialization_ns": 85840, + "serialized_bytes": 1300, + "statement_ns": 452242, + "success": true + }, + { + "mutex_wait_ns": 370, + "serialization_ns": 33703, + "serialized_bytes": 610, + "statement_ns": 550916, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 28453, + "serialized_bytes": 610, + "statement_ns": 364068, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 48139, + "serialized_bytes": 1034, + "statement_ns": 397320, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 50394, + "serialized_bytes": 1073, + "statement_ns": 458424, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 48791, + "serialized_bytes": 1081, + "statement_ns": 440591, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 54712, + "serialized_bytes": 1296, + "statement_ns": 427346, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 27842, + "serialized_bytes": 610, + "statement_ns": 523415, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 28473, + "serialized_bytes": 610, + "statement_ns": 390538, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 42789, + "serialized_bytes": 1034, + "statement_ns": 437444, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 44984, + "serialized_bytes": 1073, + "statement_ns": 448846, + "success": true + }, + { + "mutex_wait_ns": 270, + "serialization_ns": 76723, + "serialized_bytes": 1081, + "statement_ns": 403371, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 53981, + "serialized_bytes": 1296, + "statement_ns": 400977, + "success": true + }, + { + "mutex_wait_ns": 410, + "serialization_ns": 26881, + "serialized_bytes": 612, + "statement_ns": 566686, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 27371, + "serialized_bytes": 612, + "statement_ns": 443647, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 55373, + "serialized_bytes": 1038, + "statement_ns": 381902, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 45114, + "serialized_bytes": 1077, + "statement_ns": 439278, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 46637, + "serialized_bytes": 1085, + "statement_ns": 550214, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 56396, + "serialized_bytes": 1300, + "statement_ns": 488920, + "success": true + }, + { + "mutex_wait_ns": 370, + "serialization_ns": 27762, + "serialized_bytes": 612, + "statement_ns": 416947, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 28473, + "serialized_bytes": 612, + "statement_ns": 404192, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 45705, + "serialized_bytes": 1038, + "statement_ns": 358578, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 45104, + "serialized_bytes": 1077, + "statement_ns": 496745, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 45856, + "serialized_bytes": 1085, + "statement_ns": 537711, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 54341, + "serialized_bytes": 1300, + "statement_ns": 384476, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 2832072, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=1", + "COMPILER=gcc-11.4.0", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_PTHREADS", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "HTTP", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 123572927, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 121666742, + 121508447, + 121390236, + 121239966, + 121120102, + 121003445, + 120887308, + 120775138, + 120663080, + 120526775, + 120411881, + 120312977, + 120225624, + 120139102, + 120030330, + 119894647, + 119823695, + 119713578, + 119593485, + 119477178, + 119354830, + 119210691, + 119093853, + 118980322, + 118867120, + 118749481, + 118623796, + 118564175, + 118450613, + 118327243, + 118163348, + 118035851 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 111414047, + 219369, + 165278 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 111414047, + "end_ns": 123217016, + "in_window": true, + "scheduled_ns": null, + "start_ns": 11802969, + "success": true + }, + { + "elapsed_ns": 219369, + "end_ns": 133511816, + "in_window": false, + "scheduled_ns": null, + "start_ns": 133292447, + "success": true + }, + { + "elapsed_ns": 165278, + "end_ns": 143751864, + "in_window": false, + "scheduled_ns": null, + "start_ns": 143586586, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 111691147, + 705285, + 945093, + 165516 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 11, + "samples": [ + { + "elapsed_ns": 111691147, + "end_ns": 124542605, + "in_window": true, + "scheduled_ns": 12851458, + "start_ns": 124542605, + "success": true + }, + { + "elapsed_ns": 705285, + "end_ns": 133556743, + "in_window": false, + "scheduled_ns": 132851458, + "start_ns": 133556743, + "success": true + }, + { + "elapsed_ns": 945093, + "end_ns": 143796551, + "in_window": false, + "scheduled_ns": 142851458, + "start_ns": 143796551, + "success": true + }, + { + "elapsed_ns": 165516, + "end_ns": 153016974, + "in_window": false, + "scheduled_ns": 152851458, + "start_ns": 153016974, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 126440144, + "window_start_ns": 2867217 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 1, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 401, + "serialization_ns": 27932, + "serialized_bytes": 612, + "statement_ns": 635926, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 27602, + "serialized_bytes": 612, + "statement_ns": 478252, + "success": true + }, + { + "mutex_wait_ns": 290, + "serialization_ns": 44604, + "serialized_bytes": 1038, + "statement_ns": 419012, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 46116, + "serialized_bytes": 1077, + "statement_ns": 516083, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 46897, + "serialized_bytes": 1085, + "statement_ns": 391000, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 54131, + "serialized_bytes": 1300, + "statement_ns": 398673, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 26749, + "serialized_bytes": 610, + "statement_ns": 982362, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 27250, + "serialized_bytes": 610, + "statement_ns": 609156, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 43511, + "serialized_bytes": 1034, + "statement_ns": 468424, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 45565, + "serialized_bytes": 1073, + "statement_ns": 418099, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 74549, + "serialized_bytes": 1081, + "statement_ns": 551008, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 54632, + "serialized_bytes": 1296, + "statement_ns": 422988, + "success": true + }, + { + "mutex_wait_ns": 390, + "serialization_ns": 26870, + "serialized_bytes": 610, + "statement_ns": 441484, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 27401, + "serialized_bytes": 610, + "statement_ns": 459106, + "success": true + }, + { + "mutex_wait_ns": 150, + "serialization_ns": 43632, + "serialized_bytes": 1034, + "statement_ns": 379037, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 45425, + "serialized_bytes": 1073, + "statement_ns": 437767, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 46267, + "serialized_bytes": 1081, + "statement_ns": 487289, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 53820, + "serialized_bytes": 1296, + "statement_ns": 476669, + "success": true + }, + { + "mutex_wait_ns": 340, + "serialization_ns": 27251, + "serialized_bytes": 612, + "statement_ns": 403052, + "success": true + }, + { + "mutex_wait_ns": 150, + "serialization_ns": 28443, + "serialized_bytes": 612, + "statement_ns": 505313, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46367, + "serialized_bytes": 1038, + "statement_ns": 409624, + "success": true + }, + { + "mutex_wait_ns": 250, + "serialization_ns": 78246, + "serialized_bytes": 1077, + "statement_ns": 397882, + "success": true + }, + { + "mutex_wait_ns": 161, + "serialization_ns": 48640, + "serialized_bytes": 1085, + "statement_ns": 478612, + "success": true + }, + { + "mutex_wait_ns": 270, + "serialization_ns": 54963, + "serialized_bytes": 1300, + "statement_ns": 408312, + "success": true + }, + { + "mutex_wait_ns": 340, + "serialization_ns": 26900, + "serialized_bytes": 612, + "statement_ns": 433389, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 28544, + "serialized_bytes": 612, + "statement_ns": 367976, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 46046, + "serialized_bytes": 1038, + "statement_ns": 490195, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 45555, + "serialized_bytes": 1077, + "statement_ns": 409364, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 45875, + "serialized_bytes": 1085, + "statement_ns": 396660, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 53861, + "serialized_bytes": 1300, + "statement_ns": 498340, + "success": true + }, + { + "mutex_wait_ns": 370, + "serialization_ns": 26810, + "serialized_bytes": 612, + "statement_ns": 410947, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 27761, + "serialized_bytes": 612, + "statement_ns": 364309, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 44232, + "serialized_bytes": 1038, + "statement_ns": 479143, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 45465, + "serialized_bytes": 1077, + "statement_ns": 431865, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 46016, + "serialized_bytes": 1085, + "statement_ns": 422538, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 54632, + "serialized_bytes": 1300, + "statement_ns": 603926, + "success": true + }, + { + "mutex_wait_ns": 340, + "serialization_ns": 27481, + "serialized_bytes": 612, + "statement_ns": 490575, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 27521, + "serialized_bytes": 612, + "statement_ns": 397872, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46046, + "serialized_bytes": 1038, + "statement_ns": 508068, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 48250, + "serialized_bytes": 1077, + "statement_ns": 433559, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 48912, + "serialized_bytes": 1085, + "statement_ns": 404023, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 57127, + "serialized_bytes": 1300, + "statement_ns": 425053, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 26830, + "serialized_bytes": 612, + "statement_ns": 497808, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 27260, + "serialized_bytes": 612, + "statement_ns": 448216, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 43731, + "serialized_bytes": 1038, + "statement_ns": 408822, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 45394, + "serialized_bytes": 1077, + "statement_ns": 446222, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 46136, + "serialized_bytes": 1085, + "statement_ns": 375531, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 53539, + "serialized_bytes": 1300, + "statement_ns": 400577, + "success": true + }, + { + "mutex_wait_ns": 350, + "serialization_ns": 26700, + "serialized_bytes": 610, + "statement_ns": 517025, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 27281, + "serialized_bytes": 610, + "statement_ns": 436915, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 44102, + "serialized_bytes": 1034, + "statement_ns": 376562, + "success": true + }, + { + "mutex_wait_ns": 1753, + "serialization_ns": 48551, + "serialized_bytes": 1073, + "statement_ns": 515482, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 46807, + "serialized_bytes": 1081, + "statement_ns": 493361, + "success": true + }, + { + "mutex_wait_ns": 260, + "serialization_ns": 64400, + "serialized_bytes": 1296, + "statement_ns": 501576, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 27972, + "serialized_bytes": 612, + "statement_ns": 497358, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 28493, + "serialized_bytes": 612, + "statement_ns": 382875, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46106, + "serialized_bytes": 1038, + "statement_ns": 436985, + "success": true + }, + { + "mutex_wait_ns": 231, + "serialization_ns": 46437, + "serialized_bytes": 1077, + "statement_ns": 471719, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 46657, + "serialized_bytes": 1085, + "statement_ns": 389656, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 54832, + "serialized_bytes": 1300, + "statement_ns": 390839, + "success": true + }, + { + "mutex_wait_ns": 350, + "serialization_ns": 27962, + "serialized_bytes": 612, + "statement_ns": 460409, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 28883, + "serialized_bytes": 612, + "statement_ns": 414413, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 46727, + "serialized_bytes": 1038, + "statement_ns": 439540, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 45675, + "serialized_bytes": 1077, + "statement_ns": 428048, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 47419, + "serialized_bytes": 1085, + "statement_ns": 581975, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 55083, + "serialized_bytes": 1300, + "statement_ns": 532694, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 26670, + "serialized_bytes": 610, + "statement_ns": 512666, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 27291, + "serialized_bytes": 610, + "statement_ns": 445762, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 43381, + "serialized_bytes": 1034, + "statement_ns": 397401, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 45425, + "serialized_bytes": 1073, + "statement_ns": 413502, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 46667, + "serialized_bytes": 1081, + "statement_ns": 442646, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 54532, + "serialized_bytes": 1296, + "statement_ns": 380109, + "success": true + }, + { + "mutex_wait_ns": 390, + "serialization_ns": 26650, + "serialized_bytes": 610, + "statement_ns": 483923, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 27071, + "serialized_bytes": 610, + "statement_ns": 556909, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 43381, + "serialized_bytes": 1034, + "statement_ns": 393524, + "success": true + }, + { + "mutex_wait_ns": 280, + "serialization_ns": 46237, + "serialized_bytes": 1073, + "statement_ns": 426045, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 46557, + "serialized_bytes": 1081, + "statement_ns": 389517, + "success": true + }, + { + "mutex_wait_ns": 261, + "serialization_ns": 60963, + "serialized_bytes": 1296, + "statement_ns": 596232, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 28393, + "serialized_bytes": 612, + "statement_ns": 475988, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 28483, + "serialized_bytes": 612, + "statement_ns": 376663, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 45605, + "serialized_bytes": 1038, + "statement_ns": 451441, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 45895, + "serialized_bytes": 1077, + "statement_ns": 446382, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 47208, + "serialized_bytes": 1085, + "statement_ns": 474145, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 57016, + "serialized_bytes": 1300, + "statement_ns": 470467, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 29244, + "serialized_bytes": 612, + "statement_ns": 414944, + "success": true + }, + { + "mutex_wait_ns": 150, + "serialization_ns": 30066, + "serialized_bytes": 612, + "statement_ns": 367826, + "success": true + }, + { + "mutex_wait_ns": 251, + "serialization_ns": 50624, + "serialized_bytes": 1038, + "statement_ns": 450721, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48250, + "serialized_bytes": 1077, + "statement_ns": 488668, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 56816, + "serialized_bytes": 1085, + "statement_ns": 467191, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 65832, + "serialized_bytes": 1300, + "statement_ns": 577276, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 31509, + "serialized_bytes": 612, + "statement_ns": 437256, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 58159, + "serialized_bytes": 612, + "statement_ns": 394957, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 48741, + "serialized_bytes": 1038, + "statement_ns": 665010, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 50785, + "serialized_bytes": 1077, + "statement_ns": 626999, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 54973, + "serialized_bytes": 1085, + "statement_ns": 445040, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 65141, + "serialized_bytes": 1300, + "statement_ns": 449568, + "success": true + }, + { + "mutex_wait_ns": 350, + "serialization_ns": 31249, + "serialized_bytes": 612, + "statement_ns": 480356, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 31780, + "serialized_bytes": 612, + "statement_ns": 360142, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 52487, + "serialized_bytes": 1038, + "statement_ns": 388394, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 50775, + "serialized_bytes": 1077, + "statement_ns": 500404, + "success": true + }, + { + "mutex_wait_ns": 161, + "serialization_ns": 51325, + "serialized_bytes": 1085, + "statement_ns": 440701, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 60313, + "serialized_bytes": 1300, + "statement_ns": 482095, + "success": true + }, + { + "mutex_wait_ns": 341, + "serialization_ns": 31599, + "serialized_bytes": 612, + "statement_ns": 526692, + "success": true + }, + { + "mutex_wait_ns": 140, + "serialization_ns": 31779, + "serialized_bytes": 612, + "statement_ns": 480186, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 52297, + "serialized_bytes": 1038, + "statement_ns": 436604, + "success": true + }, + { + "mutex_wait_ns": 321, + "serialization_ns": 55543, + "serialized_bytes": 1077, + "statement_ns": 496255, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 55333, + "serialized_bytes": 1085, + "statement_ns": 405817, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 65211, + "serialized_bytes": 1300, + "statement_ns": 424341, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 31138, + "serialized_bytes": 612, + "statement_ns": 450690, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 33743, + "serialized_bytes": 612, + "statement_ns": 419061, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 45856, + "serialized_bytes": 1038, + "statement_ns": 444209, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 46296, + "serialized_bytes": 1077, + "statement_ns": 528416, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 47028, + "serialized_bytes": 1085, + "statement_ns": 564964, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 54542, + "serialized_bytes": 1300, + "statement_ns": 535158, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 27842, + "serialized_bytes": 610, + "statement_ns": 450951, + "success": true + }, + { + "mutex_wait_ns": 150, + "serialization_ns": 28203, + "serialized_bytes": 610, + "statement_ns": 517986, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 45725, + "serialized_bytes": 1034, + "statement_ns": 411107, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 47849, + "serialized_bytes": 1073, + "statement_ns": 422197, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 51346, + "serialized_bytes": 1081, + "statement_ns": 447966, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 60272, + "serialized_bytes": 1296, + "statement_ns": 439289, + "success": true + }, + { + "mutex_wait_ns": 360, + "serialization_ns": 28543, + "serialized_bytes": 610, + "statement_ns": 482571, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 28443, + "serialized_bytes": 610, + "statement_ns": 2841780, + "success": true + }, + { + "mutex_wait_ns": 161, + "serialization_ns": 52347, + "serialized_bytes": 1034, + "statement_ns": 577817, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 54733, + "serialized_bytes": 1073, + "statement_ns": 534527, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 55384, + "serialized_bytes": 1081, + "statement_ns": 484103, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 64751, + "serialized_bytes": 1296, + "statement_ns": 545577, + "success": true + }, + { + "mutex_wait_ns": 360, + "serialization_ns": 29215, + "serialized_bytes": 612, + "statement_ns": 478773, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 29936, + "serialized_bytes": 612, + "statement_ns": 410556, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 51586, + "serialized_bytes": 1038, + "statement_ns": 490094, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 50504, + "serialized_bytes": 1077, + "statement_ns": 377394, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 51326, + "serialized_bytes": 1085, + "statement_ns": 449929, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 61134, + "serialized_bytes": 1300, + "statement_ns": 505332, + "success": true + }, + { + "mutex_wait_ns": 341, + "serialization_ns": 29325, + "serialized_bytes": 612, + "statement_ns": 508568, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 29835, + "serialized_bytes": 612, + "statement_ns": 425674, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 48620, + "serialized_bytes": 1038, + "statement_ns": 543994, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 48260, + "serialized_bytes": 1077, + "statement_ns": 534186, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 51486, + "serialized_bytes": 1085, + "statement_ns": 461080, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 60242, + "serialized_bytes": 1300, + "statement_ns": 553864, + "success": true + }, + { + "mutex_wait_ns": 340, + "serialization_ns": 29395, + "serialized_bytes": 612, + "statement_ns": 467613, + "success": true + }, + { + "mutex_wait_ns": 130, + "serialization_ns": 29695, + "serialized_bytes": 612, + "statement_ns": 446203, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 45866, + "serialized_bytes": 1038, + "statement_ns": 407840, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48050, + "serialized_bytes": 1077, + "statement_ns": 546459, + "success": true + }, + { + "mutex_wait_ns": 161, + "serialization_ns": 48701, + "serialized_bytes": 1085, + "statement_ns": 412339, + "success": true + }, + { + "mutex_wait_ns": 271, + "serialization_ns": 60582, + "serialized_bytes": 1300, + "statement_ns": 425824, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 29305, + "serialized_bytes": 610, + "statement_ns": 759456, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 33632, + "serialized_bytes": 610, + "statement_ns": 521101, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 48501, + "serialized_bytes": 1034, + "statement_ns": 480106, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 50945, + "serialized_bytes": 1073, + "statement_ns": 614296, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 51386, + "serialized_bytes": 1081, + "statement_ns": 474705, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 64751, + "serialized_bytes": 1296, + "statement_ns": 571455, + "success": true + }, + { + "mutex_wait_ns": 360, + "serialization_ns": 31319, + "serialized_bytes": 610, + "statement_ns": 632059, + "success": true + }, + { + "mutex_wait_ns": 161, + "serialization_ns": 29895, + "serialized_bytes": 610, + "statement_ns": 484624, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 48400, + "serialized_bytes": 1034, + "statement_ns": 563551, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 54331, + "serialized_bytes": 1073, + "statement_ns": 594529, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 55063, + "serialized_bytes": 1081, + "statement_ns": 446062, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 64790, + "serialized_bytes": 1296, + "statement_ns": 488571, + "success": true + }, + { + "mutex_wait_ns": 381, + "serialization_ns": 31228, + "serialized_bytes": 612, + "statement_ns": 568070, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 31900, + "serialized_bytes": 612, + "statement_ns": 455319, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 45885, + "serialized_bytes": 1038, + "statement_ns": 455088, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 48029, + "serialized_bytes": 1077, + "statement_ns": 467322, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 51976, + "serialized_bytes": 1085, + "statement_ns": 539817, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 60342, + "serialized_bytes": 1300, + "statement_ns": 476488, + "success": true + }, + { + "mutex_wait_ns": 380, + "serialization_ns": 30618, + "serialized_bytes": 612, + "statement_ns": 516584, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 29946, + "serialized_bytes": 612, + "statement_ns": 515502, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 48751, + "serialized_bytes": 1038, + "statement_ns": 472401, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 50614, + "serialized_bytes": 1077, + "statement_ns": 525750, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 51526, + "serialized_bytes": 1085, + "statement_ns": 563952, + "success": true + }, + { + "mutex_wait_ns": 241, + "serialization_ns": 88665, + "serialized_bytes": 1300, + "statement_ns": 449708, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 27852, + "serialized_bytes": 612, + "statement_ns": 512499, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 32170, + "serialized_bytes": 612, + "statement_ns": 661554, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52418, + "serialized_bytes": 1038, + "statement_ns": 480246, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 54462, + "serialized_bytes": 1077, + "statement_ns": 481188, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 55233, + "serialized_bytes": 1085, + "statement_ns": 565074, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 64951, + "serialized_bytes": 1300, + "statement_ns": 471569, + "success": true + }, + { + "mutex_wait_ns": 370, + "serialization_ns": 34134, + "serialized_bytes": 610, + "statement_ns": 503329, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 63399, + "serialized_bytes": 610, + "statement_ns": 479895, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46016, + "serialized_bytes": 1034, + "statement_ns": 584450, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47950, + "serialized_bytes": 1073, + "statement_ns": 469626, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 48350, + "serialized_bytes": 1081, + "statement_ns": 444609, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 60313, + "serialized_bytes": 1296, + "statement_ns": 704084, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 29555, + "serialized_bytes": 612, + "statement_ns": 455159, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 29845, + "serialized_bytes": 612, + "statement_ns": 419682, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52378, + "serialized_bytes": 1038, + "statement_ns": 466210, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 54612, + "serialized_bytes": 1077, + "statement_ns": 459728, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 55212, + "serialized_bytes": 1085, + "statement_ns": 401028, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 64890, + "serialized_bytes": 1300, + "statement_ns": 516363, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 31289, + "serialized_bytes": 612, + "statement_ns": 421967, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 58519, + "serialized_bytes": 612, + "statement_ns": 399766, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 51926, + "serialized_bytes": 1038, + "statement_ns": 534176, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 47990, + "serialized_bytes": 1077, + "statement_ns": 388074, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 48290, + "serialized_bytes": 1085, + "statement_ns": 378075, + "success": true + }, + { + "mutex_wait_ns": 251, + "serialization_ns": 89506, + "serialized_bytes": 1300, + "statement_ns": 423680, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 3843518, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=1", + "COMPILER=gcc-11.4.0", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_PTHREADS", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "HTTP", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 110792794, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 108862144, + 108702666, + 108563296, + 108445597, + 108331203, + 108216229, + 108101154, + 107990277, + 107853933, + 107736925, + 107659271, + 107554886, + 107420415, + 107305341, + 107163496, + 107048622, + 106934468, + 106819303, + 106704649, + 106590787, + 106451638, + 106335140, + 106210097, + 106088291, + 105973636, + 105878109, + 105738418, + 105706408, + 105630487, + 105523527, + 105362978, + 105230170 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 98636122, + 183883, + 176469 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 98636122, + "end_ns": 110436577, + "in_window": true, + "scheduled_ns": null, + "start_ns": 11800455, + "success": true + }, + { + "elapsed_ns": 183883, + "end_ns": 120697604, + "in_window": false, + "scheduled_ns": null, + "start_ns": 120513721, + "success": true + }, + { + "elapsed_ns": 176469, + "end_ns": 130947812, + "in_window": false, + "scheduled_ns": null, + "start_ns": 130771343, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 98882993, + 1893818, + 993960, + 1202369 + ], + "failures": 0, + "in_window_samples": 2, + "missed_periods": 9, + "samples": [ + { + "elapsed_ns": 98882993, + "end_ns": 111730554, + "in_window": true, + "scheduled_ns": 12847561, + "start_ns": 111730554, + "success": true + }, + { + "elapsed_ns": 1893818, + "end_ns": 114741379, + "in_window": true, + "scheduled_ns": 112847561, + "start_ns": 114741379, + "success": true + }, + { + "elapsed_ns": 993960, + "end_ns": 123841521, + "in_window": false, + "scheduled_ns": 122847561, + "start_ns": 123841521, + "success": true + }, + { + "elapsed_ns": 1202369, + "end_ns": 134049930, + "in_window": false, + "scheduled_ns": 132847561, + "start_ns": 134049930, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 113655734, + "window_start_ns": 2862940 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 2, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 390, + "serialization_ns": 28263, + "serialized_bytes": 612, + "statement_ns": 604257, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 27321, + "serialized_bytes": 612, + "statement_ns": 519239, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 44322, + "serialized_bytes": 1038, + "statement_ns": 433328, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 46136, + "serialized_bytes": 1077, + "statement_ns": 415705, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46677, + "serialized_bytes": 1085, + "statement_ns": 467983, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53540, + "serialized_bytes": 1300, + "statement_ns": 417749, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 26619, + "serialized_bytes": 610, + "statement_ns": 469155, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 27041, + "serialized_bytes": 610, + "statement_ns": 473403, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 46426, + "serialized_bytes": 1034, + "statement_ns": 386491, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 45405, + "serialized_bytes": 1073, + "statement_ns": 438829, + "success": true + }, + { + "mutex_wait_ns": 161, + "serialization_ns": 46927, + "serialized_bytes": 1081, + "statement_ns": 456411, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 54321, + "serialized_bytes": 1296, + "statement_ns": 411768, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 26960, + "serialized_bytes": 610, + "statement_ns": 385158, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 27422, + "serialized_bytes": 610, + "statement_ns": 705195, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 44483, + "serialized_bytes": 1034, + "statement_ns": 545938, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 46547, + "serialized_bytes": 1073, + "statement_ns": 423460, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 46858, + "serialized_bytes": 1081, + "statement_ns": 429221, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 56575, + "serialized_bytes": 1296, + "statement_ns": 519769, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 28102, + "serialized_bytes": 612, + "statement_ns": 463374, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 28523, + "serialized_bytes": 612, + "statement_ns": 425183, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 46417, + "serialized_bytes": 1038, + "statement_ns": 490334, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 48400, + "serialized_bytes": 1077, + "statement_ns": 418180, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 48751, + "serialized_bytes": 1085, + "statement_ns": 381151, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 57016, + "serialized_bytes": 1300, + "statement_ns": 462612, + "success": true + }, + { + "mutex_wait_ns": 381, + "serialization_ns": 27922, + "serialized_bytes": 612, + "statement_ns": 471890, + "success": true + }, + { + "mutex_wait_ns": 161, + "serialization_ns": 28543, + "serialized_bytes": 612, + "statement_ns": 410215, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 46336, + "serialized_bytes": 1038, + "statement_ns": 464426, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51076, + "serialized_bytes": 1077, + "statement_ns": 444609, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 51636, + "serialized_bytes": 1085, + "statement_ns": 402090, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 60132, + "serialized_bytes": 1300, + "statement_ns": 437806, + "success": true + }, + { + "mutex_wait_ns": 370, + "serialization_ns": 27952, + "serialized_bytes": 612, + "statement_ns": 395789, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 28424, + "serialized_bytes": 612, + "statement_ns": 411036, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 46266, + "serialized_bytes": 1038, + "statement_ns": 388044, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 52779, + "serialized_bytes": 1077, + "statement_ns": 537202, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 48680, + "serialized_bytes": 1085, + "statement_ns": 398052, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 56816, + "serialized_bytes": 1300, + "statement_ns": 473323, + "success": true + }, + { + "mutex_wait_ns": 370, + "serialization_ns": 29726, + "serialized_bytes": 610, + "statement_ns": 469616, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 29826, + "serialized_bytes": 610, + "statement_ns": 443157, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 43912, + "serialized_bytes": 1034, + "statement_ns": 358989, + "success": true + }, + { + "mutex_wait_ns": 261, + "serialization_ns": 46436, + "serialized_bytes": 1073, + "statement_ns": 377123, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 48470, + "serialized_bytes": 1081, + "statement_ns": 386240, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 56685, + "serialized_bytes": 1296, + "statement_ns": 522324, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 27661, + "serialized_bytes": 610, + "statement_ns": 453245, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 28483, + "serialized_bytes": 610, + "statement_ns": 691490, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 43922, + "serialized_bytes": 1034, + "statement_ns": 586123, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47949, + "serialized_bytes": 1073, + "statement_ns": 438508, + "success": true + }, + { + "mutex_wait_ns": 161, + "serialization_ns": 48700, + "serialized_bytes": 1081, + "statement_ns": 384156, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 56615, + "serialized_bytes": 1296, + "statement_ns": 483271, + "success": true + }, + { + "mutex_wait_ns": 370, + "serialization_ns": 29385, + "serialized_bytes": 612, + "statement_ns": 401349, + "success": true + }, + { + "mutex_wait_ns": 150, + "serialization_ns": 31990, + "serialized_bytes": 612, + "statement_ns": 413531, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 52388, + "serialized_bytes": 1038, + "statement_ns": 522124, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 46126, + "serialized_bytes": 1077, + "statement_ns": 465248, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 48751, + "serialized_bytes": 1085, + "statement_ns": 440011, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 56775, + "serialized_bytes": 1300, + "statement_ns": 622771, + "success": true + }, + { + "mutex_wait_ns": 330, + "serialization_ns": 27972, + "serialized_bytes": 612, + "statement_ns": 463755, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 29655, + "serialized_bytes": 612, + "statement_ns": 385670, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 48490, + "serialized_bytes": 1038, + "statement_ns": 397822, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 50995, + "serialized_bytes": 1077, + "statement_ns": 604377, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 51295, + "serialized_bytes": 1085, + "statement_ns": 419032, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 64942, + "serialized_bytes": 1300, + "statement_ns": 399996, + "success": true + }, + { + "mutex_wait_ns": 401, + "serialization_ns": 31288, + "serialized_bytes": 612, + "statement_ns": 546078, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 29906, + "serialized_bytes": 612, + "statement_ns": 367326, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 48530, + "serialized_bytes": 1038, + "statement_ns": 436003, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 54862, + "serialized_bytes": 1077, + "statement_ns": 437185, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 55102, + "serialized_bytes": 1085, + "statement_ns": 450620, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 65162, + "serialized_bytes": 1300, + "statement_ns": 434881, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 29374, + "serialized_bytes": 612, + "statement_ns": 490374, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 29786, + "serialized_bytes": 612, + "statement_ns": 359931, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 50935, + "serialized_bytes": 1038, + "statement_ns": 386891, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 52438, + "serialized_bytes": 1077, + "statement_ns": 455670, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 48720, + "serialized_bytes": 1085, + "statement_ns": 416346, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 63979, + "serialized_bytes": 1300, + "statement_ns": 622390, + "success": true + }, + { + "mutex_wait_ns": 370, + "serialization_ns": 27983, + "serialized_bytes": 612, + "statement_ns": 466530, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 56976, + "serialized_bytes": 612, + "statement_ns": 468504, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 48611, + "serialized_bytes": 1038, + "statement_ns": 414082, + "success": true + }, + { + "mutex_wait_ns": 260, + "serialization_ns": 51046, + "serialized_bytes": 1077, + "statement_ns": 442315, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 61074, + "serialized_bytes": 1085, + "statement_ns": 513809, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 64730, + "serialized_bytes": 1300, + "statement_ns": 520370, + "success": true + }, + { + "mutex_wait_ns": 350, + "serialization_ns": 28503, + "serialized_bytes": 612, + "statement_ns": 505573, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 29845, + "serialized_bytes": 612, + "statement_ns": 427607, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 48561, + "serialized_bytes": 1038, + "statement_ns": 423390, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 54622, + "serialized_bytes": 1077, + "statement_ns": 443848, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 84398, + "serialized_bytes": 1085, + "statement_ns": 532904, + "success": true + }, + { + "mutex_wait_ns": 431, + "serialization_ns": 60312, + "serialized_bytes": 1300, + "statement_ns": 451973, + "success": true + }, + { + "mutex_wait_ns": 360, + "serialization_ns": 29135, + "serialized_bytes": 610, + "statement_ns": 469977, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 29726, + "serialized_bytes": 610, + "statement_ns": 488341, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 46116, + "serialized_bytes": 1034, + "statement_ns": 454187, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 47969, + "serialized_bytes": 1073, + "statement_ns": 468123, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 51666, + "serialized_bytes": 1081, + "statement_ns": 386501, + "success": true + }, + { + "mutex_wait_ns": 231, + "serialization_ns": 60081, + "serialized_bytes": 1296, + "statement_ns": 559463, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 29234, + "serialized_bytes": 612, + "statement_ns": 415866, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 29976, + "serialized_bytes": 612, + "statement_ns": 361144, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 45895, + "serialized_bytes": 1038, + "statement_ns": 481568, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 48110, + "serialized_bytes": 1077, + "statement_ns": 411808, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 48470, + "serialized_bytes": 1085, + "statement_ns": 470268, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 56806, + "serialized_bytes": 1300, + "statement_ns": 526713, + "success": true + }, + { + "mutex_wait_ns": 360, + "serialization_ns": 29395, + "serialized_bytes": 612, + "statement_ns": 528236, + "success": true + }, + { + "mutex_wait_ns": 150, + "serialization_ns": 31980, + "serialized_bytes": 612, + "statement_ns": 419703, + "success": true + }, + { + "mutex_wait_ns": 311, + "serialization_ns": 75240, + "serialized_bytes": 1038, + "statement_ns": 709623, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 54792, + "serialized_bytes": 1077, + "statement_ns": 528856, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 60273, + "serialized_bytes": 1085, + "statement_ns": 459797, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 70813, + "serialized_bytes": 1300, + "statement_ns": 569222, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 33743, + "serialized_bytes": 612, + "statement_ns": 434791, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 34595, + "serialized_bytes": 612, + "statement_ns": 398082, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 45736, + "serialized_bytes": 1038, + "statement_ns": 423009, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48290, + "serialized_bytes": 1077, + "statement_ns": 481588, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 51306, + "serialized_bytes": 1085, + "statement_ns": 462112, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 60302, + "serialized_bytes": 1300, + "statement_ns": 404224, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 29325, + "serialized_bytes": 612, + "statement_ns": 489663, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 29876, + "serialized_bytes": 612, + "statement_ns": 374328, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48440, + "serialized_bytes": 1038, + "statement_ns": 417409, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 50875, + "serialized_bytes": 1077, + "statement_ns": 400196, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 51456, + "serialized_bytes": 1085, + "statement_ns": 341747, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 60232, + "serialized_bytes": 1300, + "statement_ns": 367545, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 27731, + "serialized_bytes": 612, + "statement_ns": 412339, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 28293, + "serialized_bytes": 612, + "statement_ns": 326760, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48230, + "serialized_bytes": 1038, + "statement_ns": 351255, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 45504, + "serialized_bytes": 1077, + "statement_ns": 336718, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 46457, + "serialized_bytes": 1085, + "statement_ns": 333843, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 54341, + "serialized_bytes": 1300, + "statement_ns": 420834, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 27651, + "serialized_bytes": 612, + "statement_ns": 369900, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 58709, + "serialized_bytes": 612, + "statement_ns": 338170, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 43811, + "serialized_bytes": 1038, + "statement_ns": 334775, + "success": true + }, + { + "mutex_wait_ns": 230, + "serialization_ns": 45716, + "serialized_bytes": 1077, + "statement_ns": 364680, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46778, + "serialized_bytes": 1085, + "statement_ns": 344412, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 54192, + "serialized_bytes": 1300, + "statement_ns": 369349, + "success": true + }, + { + "mutex_wait_ns": 341, + "serialization_ns": 26750, + "serialized_bytes": 612, + "statement_ns": 350464, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 27110, + "serialized_bytes": 612, + "statement_ns": 313514, + "success": true + }, + { + "mutex_wait_ns": 251, + "serialization_ns": 51065, + "serialized_bytes": 1038, + "statement_ns": 338671, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 45906, + "serialized_bytes": 1077, + "statement_ns": 331197, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 46616, + "serialized_bytes": 1085, + "statement_ns": 565094, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 53940, + "serialized_bytes": 1300, + "statement_ns": 425614, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 26459, + "serialized_bytes": 610, + "statement_ns": 401458, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 27340, + "serialized_bytes": 610, + "statement_ns": 335706, + "success": true + }, + { + "mutex_wait_ns": 260, + "serialization_ns": 72766, + "serialized_bytes": 1034, + "statement_ns": 367455, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 50604, + "serialized_bytes": 1073, + "statement_ns": 343210, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 46347, + "serialized_bytes": 1081, + "statement_ns": 382393, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 54381, + "serialized_bytes": 1296, + "statement_ns": 450440, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 27512, + "serialized_bytes": 612, + "statement_ns": 398724, + "success": true + }, + { + "mutex_wait_ns": 140, + "serialization_ns": 27572, + "serialized_bytes": 612, + "statement_ns": 313234, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 43982, + "serialized_bytes": 1038, + "statement_ns": 326258, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 46156, + "serialized_bytes": 1077, + "statement_ns": 317893, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 46527, + "serialized_bytes": 1085, + "statement_ns": 320308, + "success": true + }, + { + "mutex_wait_ns": 241, + "serialization_ns": 54291, + "serialized_bytes": 1300, + "statement_ns": 344052, + "success": true + }, + { + "mutex_wait_ns": 360, + "serialization_ns": 26730, + "serialized_bytes": 612, + "statement_ns": 369369, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 27521, + "serialized_bytes": 612, + "statement_ns": 319927, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 43982, + "serialized_bytes": 1038, + "statement_ns": 340715, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 44984, + "serialized_bytes": 1077, + "statement_ns": 339954, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 45855, + "serialized_bytes": 1085, + "statement_ns": 323313, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 54332, + "serialized_bytes": 1300, + "statement_ns": 439119, + "success": true + }, + { + "mutex_wait_ns": 381, + "serialization_ns": 26710, + "serialized_bytes": 612, + "statement_ns": 383104, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 26820, + "serialized_bytes": 612, + "statement_ns": 335717, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 43341, + "serialized_bytes": 1038, + "statement_ns": 336568, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46177, + "serialized_bytes": 1077, + "statement_ns": 329645, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 46728, + "serialized_bytes": 1085, + "statement_ns": 374919, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 54903, + "serialized_bytes": 1300, + "statement_ns": 347528, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 26689, + "serialized_bytes": 610, + "statement_ns": 411758, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 33313, + "serialized_bytes": 610, + "statement_ns": 320338, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 43772, + "serialized_bytes": 1034, + "statement_ns": 357076, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 45715, + "serialized_bytes": 1073, + "statement_ns": 328724, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 46316, + "serialized_bytes": 1081, + "statement_ns": 325297, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 85670, + "serialized_bytes": 1296, + "statement_ns": 376192, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 27521, + "serialized_bytes": 610, + "statement_ns": 365401, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 27251, + "serialized_bytes": 610, + "statement_ns": 314867, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 43060, + "serialized_bytes": 1034, + "statement_ns": 678585, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 45215, + "serialized_bytes": 1073, + "statement_ns": 413521, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 46407, + "serialized_bytes": 1081, + "statement_ns": 383756, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 54552, + "serialized_bytes": 1296, + "statement_ns": 335426, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 26619, + "serialized_bytes": 610, + "statement_ns": 364830, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 27291, + "serialized_bytes": 610, + "statement_ns": 315899, + "success": true + }, + { + "mutex_wait_ns": 270, + "serialization_ns": 65272, + "serialized_bytes": 1034, + "statement_ns": 330156, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 45134, + "serialized_bytes": 1073, + "statement_ns": 457793, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 45816, + "serialized_bytes": 1081, + "statement_ns": 374999, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 53109, + "serialized_bytes": 1296, + "statement_ns": 479775, + "success": true + }, + { + "mutex_wait_ns": 360, + "serialization_ns": 26821, + "serialized_bytes": 610, + "statement_ns": 405887, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 28332, + "serialized_bytes": 610, + "statement_ns": 377915, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 45775, + "serialized_bytes": 1034, + "statement_ns": 406418, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 47609, + "serialized_bytes": 1073, + "statement_ns": 423049, + "success": true + }, + { + "mutex_wait_ns": 161, + "serialization_ns": 48410, + "serialized_bytes": 1081, + "statement_ns": 368687, + "success": true + }, + { + "mutex_wait_ns": 231, + "serialization_ns": 56275, + "serialized_bytes": 1296, + "statement_ns": 403332, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 27432, + "serialized_bytes": 612, + "statement_ns": 446492, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 37661, + "serialized_bytes": 612, + "statement_ns": 373377, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 45996, + "serialized_bytes": 1038, + "statement_ns": 375521, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48070, + "serialized_bytes": 1077, + "statement_ns": 382634, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 49362, + "serialized_bytes": 1085, + "statement_ns": 335966, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 56556, + "serialized_bytes": 1300, + "statement_ns": 377134, + "success": true + }, + { + "mutex_wait_ns": 330, + "serialization_ns": 27472, + "serialized_bytes": 612, + "statement_ns": 358639, + "success": true + }, + { + "mutex_wait_ns": 151, + "serialization_ns": 26800, + "serialized_bytes": 612, + "statement_ns": 358017, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 42910, + "serialized_bytes": 1038, + "statement_ns": 332189, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 45064, + "serialized_bytes": 1077, + "statement_ns": 374388, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 45936, + "serialized_bytes": 1085, + "statement_ns": 347889, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 54021, + "serialized_bytes": 1300, + "statement_ns": 337119, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 2886293, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=1", + "COMPILER=gcc-11.4.0", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_PTHREADS", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "HTTP", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 225387423, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 199289619, + 199177691, + 201519387, + 201408111, + 201293938, + 201142325, + 201011992, + 200894983, + 200781432, + 200646239, + 202487864, + 200576749, + 200417793, + 200300734, + 200184227, + 200068562, + 199955491, + 199793058, + 199663547, + 199546769, + 199424100, + 199334222, + 199208257, + 199059610, + 198938825, + 198814453, + 198684300, + 198565038, + 198441648, + 198292038, + 216935970, + 219684967 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 5359476, + 45511681, + 21769070, + 77296048, + 3763579, + 202497, + 158365, + 155109, + 150240 + ], + "failures": 0, + "in_window_samples": 7, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 5359476, + "end_ns": 17292254, + "in_window": true, + "scheduled_ns": null, + "start_ns": 11932778, + "success": true + }, + { + "elapsed_ns": 45511681, + "end_ns": 72886911, + "in_window": true, + "scheduled_ns": null, + "start_ns": 27375230, + "success": true + }, + { + "elapsed_ns": 21769070, + "end_ns": 104752111, + "in_window": true, + "scheduled_ns": null, + "start_ns": 82983041, + "success": true + }, + { + "elapsed_ns": 77296048, + "end_ns": 192137627, + "in_window": true, + "scheduled_ns": null, + "start_ns": 114841579, + "success": true + }, + { + "elapsed_ns": 3763579, + "end_ns": 206021160, + "in_window": true, + "scheduled_ns": null, + "start_ns": 202257581, + "success": true + }, + { + "elapsed_ns": 202497, + "end_ns": 216300001, + "in_window": true, + "scheduled_ns": null, + "start_ns": 216097504, + "success": true + }, + { + "elapsed_ns": 158365, + "end_ns": 226553815, + "in_window": true, + "scheduled_ns": null, + "start_ns": 226395450, + "success": true + }, + { + "elapsed_ns": 155109, + "end_ns": 236783133, + "in_window": false, + "scheduled_ns": null, + "start_ns": 236628024, + "success": true + }, + { + "elapsed_ns": 150240, + "end_ns": 247011640, + "in_window": false, + "scheduled_ns": null, + "start_ns": 246861400, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 9356160, + 71050744, + 13580343, + 82193154, + 863925, + 1441153, + 1501125, + 956340, + 1290133 + ], + "failures": 0, + "in_window_samples": 6, + "missed_periods": 16, + "samples": [ + { + "elapsed_ns": 9356160, + "end_ns": 23315154, + "in_window": true, + "scheduled_ns": 13958994, + "start_ns": 23315154, + "success": true + }, + { + "elapsed_ns": 71050744, + "end_ns": 95009738, + "in_window": true, + "scheduled_ns": 23958994, + "start_ns": 95009738, + "success": true + }, + { + "elapsed_ns": 13580343, + "end_ns": 117539337, + "in_window": true, + "scheduled_ns": 103958994, + "start_ns": 117539337, + "success": true + }, + { + "elapsed_ns": 82193154, + "end_ns": 206152148, + "in_window": true, + "scheduled_ns": 123958994, + "start_ns": 206152148, + "success": true + }, + { + "elapsed_ns": 863925, + "end_ns": 214822919, + "in_window": true, + "scheduled_ns": 213958994, + "start_ns": 214822919, + "success": true + }, + { + "elapsed_ns": 1441153, + "end_ns": 225400147, + "in_window": true, + "scheduled_ns": 223958994, + "start_ns": 225400147, + "success": true + }, + { + "elapsed_ns": 1501125, + "end_ns": 235460119, + "in_window": false, + "scheduled_ns": 233958994, + "start_ns": 235460119, + "success": true + }, + { + "elapsed_ns": 956340, + "end_ns": 244915334, + "in_window": false, + "scheduled_ns": 243958994, + "start_ns": 244915334, + "success": true + }, + { + "elapsed_ns": 1290133, + "end_ns": 255249127, + "in_window": false, + "scheduled_ns": 253958994, + "start_ns": 255249127, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 229361605, + "window_start_ns": 3974182 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 0, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 751, + "serialization_ns": 32631, + "serialized_bytes": 613, + "statement_ns": 666994, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 28082, + "serialized_bytes": 613, + "statement_ns": 440382, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 45535, + "serialized_bytes": 1040, + "statement_ns": 376733, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 45605, + "serialized_bytes": 1079, + "statement_ns": 392873, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 46507, + "serialized_bytes": 1087, + "statement_ns": 362597, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 53670, + "serialized_bytes": 1302, + "statement_ns": 362616, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 27431, + "serialized_bytes": 613, + "statement_ns": 438678, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 27190, + "serialized_bytes": 613, + "statement_ns": 357207, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 43551, + "serialized_bytes": 1040, + "statement_ns": 347247, + "success": true + }, + { + "mutex_wait_ns": 231, + "serialization_ns": 45124, + "serialized_bytes": 1079, + "statement_ns": 388965, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 45895, + "serialized_bytes": 1087, + "statement_ns": 334985, + "success": true + }, + { + "mutex_wait_ns": 240, + "serialization_ns": 53159, + "serialized_bytes": 1302, + "statement_ns": 486368, + "success": true + }, + { + "mutex_wait_ns": 461, + "serialization_ns": 43271, + "serialized_bytes": 613, + "statement_ns": 430483, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 26981, + "serialized_bytes": 613, + "statement_ns": 328563, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 42760, + "serialized_bytes": 1040, + "statement_ns": 330987, + "success": true + }, + { + "mutex_wait_ns": 290, + "serialization_ns": 75732, + "serialized_bytes": 1079, + "statement_ns": 367265, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 45716, + "serialized_bytes": 1087, + "statement_ns": 328473, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53249, + "serialized_bytes": 1302, + "statement_ns": 435733, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 26930, + "serialized_bytes": 613, + "statement_ns": 396610, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 27261, + "serialized_bytes": 613, + "statement_ns": 337590, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 43181, + "serialized_bytes": 1040, + "statement_ns": 394065, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 45955, + "serialized_bytes": 1079, + "statement_ns": 322882, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 45865, + "serialized_bytes": 1087, + "statement_ns": 358919, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 53711, + "serialized_bytes": 1302, + "statement_ns": 324906, + "success": true + }, + { + "mutex_wait_ns": 391, + "serialization_ns": 26339, + "serialized_bytes": 613, + "statement_ns": 366965, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 26840, + "serialized_bytes": 613, + "statement_ns": 315499, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 42930, + "serialized_bytes": 1040, + "statement_ns": 343009, + "success": true + }, + { + "mutex_wait_ns": 281, + "serialization_ns": 46296, + "serialized_bytes": 1079, + "statement_ns": 348560, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 45785, + "serialized_bytes": 1087, + "statement_ns": 336147, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 53550, + "serialized_bytes": 1302, + "statement_ns": 413041, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 26580, + "serialized_bytes": 613, + "statement_ns": 369579, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 26680, + "serialized_bytes": 613, + "statement_ns": 372325, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 43331, + "serialized_bytes": 1040, + "statement_ns": 332340, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 45796, + "serialized_bytes": 1079, + "statement_ns": 363217, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 46698, + "serialized_bytes": 1087, + "statement_ns": 336557, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 54803, + "serialized_bytes": 1302, + "statement_ns": 348510, + "success": true + }, + { + "mutex_wait_ns": 360, + "serialization_ns": 26410, + "serialized_bytes": 613, + "statement_ns": 386742, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 32751, + "serialized_bytes": 613, + "statement_ns": 364048, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 43331, + "serialized_bytes": 1040, + "statement_ns": 324956, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 45225, + "serialized_bytes": 1079, + "statement_ns": 317492, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 46487, + "serialized_bytes": 1087, + "statement_ns": 368237, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 54691, + "serialized_bytes": 1302, + "statement_ns": 373086, + "success": true + }, + { + "mutex_wait_ns": 411, + "serialization_ns": 27090, + "serialized_bytes": 613, + "statement_ns": 381511, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 27261, + "serialized_bytes": 613, + "statement_ns": 316180, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 43101, + "serialized_bytes": 1040, + "statement_ns": 452664, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 45294, + "serialized_bytes": 1079, + "statement_ns": 365651, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 46577, + "serialized_bytes": 1087, + "statement_ns": 403833, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 54431, + "serialized_bytes": 1302, + "statement_ns": 392231, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 27852, + "serialized_bytes": 611, + "statement_ns": 411026, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 28423, + "serialized_bytes": 611, + "statement_ns": 323714, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 45835, + "serialized_bytes": 1036, + "statement_ns": 367175, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 47930, + "serialized_bytes": 1075, + "statement_ns": 330166, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 48279, + "serialized_bytes": 1083, + "statement_ns": 321700, + "success": true + }, + { + "mutex_wait_ns": 290, + "serialization_ns": 86752, + "serialized_bytes": 1298, + "statement_ns": 381041, + "success": true + }, + { + "mutex_wait_ns": 381, + "serialization_ns": 26950, + "serialized_bytes": 613, + "statement_ns": 358148, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 27682, + "serialized_bytes": 613, + "statement_ns": 309658, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 44103, + "serialized_bytes": 1040, + "statement_ns": 327851, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 45665, + "serialized_bytes": 1079, + "statement_ns": 377504, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 46005, + "serialized_bytes": 1087, + "statement_ns": 334363, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 54461, + "serialized_bytes": 1302, + "statement_ns": 357306, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 26970, + "serialized_bytes": 611, + "statement_ns": 357477, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 32310, + "serialized_bytes": 611, + "statement_ns": 319206, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 43411, + "serialized_bytes": 1036, + "statement_ns": 325156, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 50674, + "serialized_bytes": 1075, + "statement_ns": 370891, + "success": true + }, + { + "mutex_wait_ns": 340, + "serialization_ns": 75561, + "serialized_bytes": 1083, + "statement_ns": 387243, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 53389, + "serialized_bytes": 1298, + "statement_ns": 387132, + "success": true + }, + { + "mutex_wait_ns": 370, + "serialization_ns": 26800, + "serialized_bytes": 611, + "statement_ns": 377204, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 27482, + "serialized_bytes": 611, + "statement_ns": 319375, + "success": true + }, + { + "mutex_wait_ns": 271, + "serialization_ns": 71503, + "serialized_bytes": 1036, + "statement_ns": 389726, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 45184, + "serialized_bytes": 1075, + "statement_ns": 362145, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 45395, + "serialized_bytes": 1083, + "statement_ns": 397641, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 53420, + "serialized_bytes": 1298, + "statement_ns": 333001, + "success": true + }, + { + "mutex_wait_ns": 25908, + "serialization_ns": 28594, + "serialized_bytes": 611, + "statement_ns": 377374, + "success": true + }, + { + "mutex_wait_ns": 140, + "serialization_ns": 27612, + "serialized_bytes": 611, + "statement_ns": 318063, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 43521, + "serialized_bytes": 1036, + "statement_ns": 350403, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 45194, + "serialized_bytes": 1075, + "statement_ns": 326499, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 45394, + "serialized_bytes": 1083, + "statement_ns": 332340, + "success": true + }, + { + "mutex_wait_ns": 260, + "serialization_ns": 84738, + "serialized_bytes": 1298, + "statement_ns": 376332, + "success": true + }, + { + "mutex_wait_ns": 350, + "serialization_ns": 26470, + "serialized_bytes": 613, + "statement_ns": 491066, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 26980, + "serialized_bytes": 613, + "statement_ns": 343361, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 42730, + "serialized_bytes": 1040, + "statement_ns": 324495, + "success": true + }, + { + "mutex_wait_ns": 331, + "serialization_ns": 48310, + "serialized_bytes": 1079, + "statement_ns": 369679, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 46487, + "serialized_bytes": 1087, + "statement_ns": 324756, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 56456, + "serialized_bytes": 1302, + "statement_ns": 390769, + "success": true + }, + { + "mutex_wait_ns": 350, + "serialization_ns": 27902, + "serialized_bytes": 613, + "statement_ns": 344623, + "success": true + }, + { + "mutex_wait_ns": 161, + "serialization_ns": 27381, + "serialized_bytes": 613, + "statement_ns": 413481, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 43972, + "serialized_bytes": 1040, + "statement_ns": 332961, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 45395, + "serialized_bytes": 1079, + "statement_ns": 373366, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 45905, + "serialized_bytes": 1087, + "statement_ns": 329514, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 53069, + "serialized_bytes": 1302, + "statement_ns": 403393, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 26569, + "serialized_bytes": 613, + "statement_ns": 357346, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 26931, + "serialized_bytes": 613, + "statement_ns": 356164, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 43412, + "serialized_bytes": 1040, + "statement_ns": 380740, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 45314, + "serialized_bytes": 1079, + "statement_ns": 340595, + "success": true + }, + { + "mutex_wait_ns": 241, + "serialization_ns": 75671, + "serialized_bytes": 1087, + "statement_ns": 412649, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 68668, + "serialized_bytes": 1302, + "statement_ns": 366393, + "success": true + }, + { + "mutex_wait_ns": 370, + "serialization_ns": 27351, + "serialized_bytes": 613, + "statement_ns": 394376, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 27652, + "serialized_bytes": 613, + "statement_ns": 322331, + "success": true + }, + { + "mutex_wait_ns": 281, + "serialization_ns": 81151, + "serialized_bytes": 1040, + "statement_ns": 360813, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 45264, + "serialized_bytes": 1079, + "statement_ns": 330306, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 45605, + "serialized_bytes": 1087, + "statement_ns": 355663, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 53270, + "serialized_bytes": 1302, + "statement_ns": 373156, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 26530, + "serialized_bytes": 613, + "statement_ns": 392632, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 27321, + "serialized_bytes": 613, + "statement_ns": 304557, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 47960, + "serialized_bytes": 1040, + "statement_ns": 432797, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 46166, + "serialized_bytes": 1079, + "statement_ns": 336697, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 46376, + "serialized_bytes": 1087, + "statement_ns": 339914, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 54372, + "serialized_bytes": 1302, + "statement_ns": 330987, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 27221, + "serialized_bytes": 613, + "statement_ns": 370330, + "success": true + }, + { + "mutex_wait_ns": 161, + "serialization_ns": 28593, + "serialized_bytes": 613, + "statement_ns": 312352, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 45766, + "serialized_bytes": 1040, + "statement_ns": 315669, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 45966, + "serialized_bytes": 1079, + "statement_ns": 331128, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 46637, + "serialized_bytes": 1087, + "statement_ns": 3156477, + "success": true + }, + { + "mutex_wait_ns": 271, + "serialization_ns": 66293, + "serialized_bytes": 1302, + "statement_ns": 554895, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 27982, + "serialized_bytes": 611, + "statement_ns": 553252, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 28824, + "serialized_bytes": 611, + "statement_ns": 429371, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 46056, + "serialized_bytes": 1036, + "statement_ns": 351235, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 51356, + "serialized_bytes": 1075, + "statement_ns": 380520, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 51386, + "serialized_bytes": 1083, + "statement_ns": 327711, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 60212, + "serialized_bytes": 1298, + "statement_ns": 364980, + "success": true + }, + { + "mutex_wait_ns": 381, + "serialization_ns": 28182, + "serialized_bytes": 611, + "statement_ns": 415675, + "success": true + }, + { + "mutex_wait_ns": 161, + "serialization_ns": 29014, + "serialized_bytes": 611, + "statement_ns": 360211, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 44263, + "serialized_bytes": 1036, + "statement_ns": 329164, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 45855, + "serialized_bytes": 1075, + "statement_ns": 388155, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 48421, + "serialized_bytes": 1083, + "statement_ns": 372926, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 56325, + "serialized_bytes": 1298, + "statement_ns": 370060, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 28212, + "serialized_bytes": 611, + "statement_ns": 392742, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 28403, + "serialized_bytes": 611, + "statement_ns": 379268, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 43851, + "serialized_bytes": 1036, + "statement_ns": 349993, + "success": true + }, + { + "mutex_wait_ns": 240, + "serialization_ns": 45896, + "serialized_bytes": 1075, + "statement_ns": 357216, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 46146, + "serialized_bytes": 1083, + "statement_ns": 376492, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 54021, + "serialized_bytes": 1298, + "statement_ns": 341257, + "success": true + }, + { + "mutex_wait_ns": 370, + "serialization_ns": 27972, + "serialized_bytes": 611, + "statement_ns": 376823, + "success": true + }, + { + "mutex_wait_ns": 141, + "serialization_ns": 28292, + "serialized_bytes": 611, + "statement_ns": 362465, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 45595, + "serialized_bytes": 1036, + "statement_ns": 419202, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 47719, + "serialized_bytes": 1075, + "statement_ns": 348029, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 55202, + "serialized_bytes": 1083, + "statement_ns": 366156, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 60633, + "serialized_bytes": 1298, + "statement_ns": 372896, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 28163, + "serialized_bytes": 613, + "statement_ns": 496336, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 28844, + "serialized_bytes": 613, + "statement_ns": 398102, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 46006, + "serialized_bytes": 1040, + "statement_ns": 386040, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 48160, + "serialized_bytes": 1079, + "statement_ns": 347188, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 48650, + "serialized_bytes": 1087, + "statement_ns": 370751, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 56806, + "serialized_bytes": 1302, + "statement_ns": 356205, + "success": true + }, + { + "mutex_wait_ns": 340, + "serialization_ns": 27992, + "serialized_bytes": 613, + "statement_ns": 381752, + "success": true + }, + { + "mutex_wait_ns": 150, + "serialization_ns": 28693, + "serialized_bytes": 613, + "statement_ns": 373527, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 45795, + "serialized_bytes": 1040, + "statement_ns": 349332, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 45054, + "serialized_bytes": 1079, + "statement_ns": 364600, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 45535, + "serialized_bytes": 1087, + "statement_ns": 384537, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 82514, + "serialized_bytes": 1302, + "statement_ns": 398423, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 26820, + "serialized_bytes": 613, + "statement_ns": 397702, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 28914, + "serialized_bytes": 613, + "statement_ns": 331288, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 45625, + "serialized_bytes": 1040, + "statement_ns": 369399, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 67746, + "serialized_bytes": 1079, + "statement_ns": 358399, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 45625, + "serialized_bytes": 1087, + "statement_ns": 336888, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 53811, + "serialized_bytes": 1302, + "statement_ns": 345775, + "success": true + }, + { + "mutex_wait_ns": 390, + "serialization_ns": 27331, + "serialized_bytes": 613, + "statement_ns": 555396, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 40145, + "serialized_bytes": 613, + "statement_ns": 382704, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 43962, + "serialized_bytes": 1040, + "statement_ns": 409714, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 67065, + "serialized_bytes": 1079, + "statement_ns": 387493, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 46547, + "serialized_bytes": 1087, + "statement_ns": 370271, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 54622, + "serialized_bytes": 1302, + "statement_ns": 378966, + "success": true + }, + { + "mutex_wait_ns": 390, + "serialization_ns": 27131, + "serialized_bytes": 613, + "statement_ns": 383295, + "success": true + }, + { + "mutex_wait_ns": 151, + "serialization_ns": 27250, + "serialized_bytes": 613, + "statement_ns": 329685, + "success": true + }, + { + "mutex_wait_ns": 311, + "serialization_ns": 75771, + "serialized_bytes": 1040, + "statement_ns": 370842, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 45485, + "serialized_bytes": 1079, + "statement_ns": 353429, + "success": true + }, + { + "mutex_wait_ns": 161, + "serialization_ns": 46086, + "serialized_bytes": 1087, + "statement_ns": 382333, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 53490, + "serialized_bytes": 1302, + "statement_ns": 340434, + "success": true + }, + { + "mutex_wait_ns": 370, + "serialization_ns": 27111, + "serialized_bytes": 611, + "statement_ns": 362867, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 27431, + "serialized_bytes": 611, + "statement_ns": 417719, + "success": true + }, + { + "mutex_wait_ns": 150, + "serialization_ns": 43060, + "serialized_bytes": 1036, + "statement_ns": 352137, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 45294, + "serialized_bytes": 1075, + "statement_ns": 344783, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 73678, + "serialized_bytes": 1083, + "statement_ns": 359200, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 52949, + "serialized_bytes": 1298, + "statement_ns": 392381, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 27280, + "serialized_bytes": 611, + "statement_ns": 373737, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 27351, + "serialized_bytes": 611, + "statement_ns": 317201, + "success": true + }, + { + "mutex_wait_ns": 251, + "serialization_ns": 73457, + "serialized_bytes": 1036, + "statement_ns": 373597, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 44913, + "serialized_bytes": 1075, + "statement_ns": 331768, + "success": true + }, + { + "mutex_wait_ns": 150, + "serialization_ns": 46046, + "serialized_bytes": 1083, + "statement_ns": 331399, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53640, + "serialized_bytes": 1298, + "statement_ns": 355093, + "success": true + }, + { + "mutex_wait_ns": 381, + "serialization_ns": 26590, + "serialized_bytes": 613, + "statement_ns": 431214, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 26890, + "serialized_bytes": 613, + "statement_ns": 328302, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 43080, + "serialized_bytes": 1040, + "statement_ns": 350243, + "success": true + }, + { + "mutex_wait_ns": 230, + "serialization_ns": 46106, + "serialized_bytes": 1079, + "statement_ns": 337109, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 46386, + "serialized_bytes": 1087, + "statement_ns": 328342, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 92994, + "serialized_bytes": 1302, + "statement_ns": 381221, + "success": true + }, + { + "mutex_wait_ns": 381, + "serialization_ns": 27141, + "serialized_bytes": 613, + "statement_ns": 419913, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 27552, + "serialized_bytes": 613, + "statement_ns": 335245, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 43872, + "serialized_bytes": 1040, + "statement_ns": 344813, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 45775, + "serialized_bytes": 1079, + "statement_ns": 425634, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 46837, + "serialized_bytes": 1087, + "statement_ns": 366193, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 55162, + "serialized_bytes": 1302, + "statement_ns": 428068, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 2024206, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=1", + "COMPILER=gcc-11.4.0", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_PTHREADS", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "TLS", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 196858699, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 170676167, + 170571292, + 172983209, + 172869007, + 172757219, + 172641823, + 172525557, + 173834588, + 172462048, + 172325212, + 172209417, + 172102908, + 171989727, + 171874883, + 171760129, + 171619897, + 171505554, + 171390510, + 171274492, + 171160190, + 171045366, + 170944998, + 170829943, + 170713917, + 170597160, + 170484590, + 170368313, + 170203285, + 170079494, + 169962646, + 187531613, + 191335478 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 5188337, + 12353580, + 19392248, + 85469181, + 5003015, + 204030, + 149288, + 181057, + 172392 + ], + "failures": 0, + "in_window_samples": 7, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 5188337, + "end_ns": 18057742, + "in_window": true, + "scheduled_ns": null, + "start_ns": 12869405, + "success": true + }, + { + "elapsed_ns": 12353580, + "end_ns": 40483767, + "in_window": true, + "scheduled_ns": null, + "start_ns": 28130187, + "success": true + }, + { + "elapsed_ns": 19392248, + "end_ns": 69941338, + "in_window": true, + "scheduled_ns": null, + "start_ns": 50549090, + "success": true + }, + { + "elapsed_ns": 85469181, + "end_ns": 165478586, + "in_window": true, + "scheduled_ns": null, + "start_ns": 80009405, + "success": true + }, + { + "elapsed_ns": 5003015, + "end_ns": 180565745, + "in_window": true, + "scheduled_ns": null, + "start_ns": 175562730, + "success": true + }, + { + "elapsed_ns": 204030, + "end_ns": 190852219, + "in_window": true, + "scheduled_ns": null, + "start_ns": 190648189, + "success": true + }, + { + "elapsed_ns": 149288, + "end_ns": 201078291, + "in_window": true, + "scheduled_ns": null, + "start_ns": 200929003, + "success": true + }, + { + "elapsed_ns": 181057, + "end_ns": 211337856, + "in_window": false, + "scheduled_ns": null, + "start_ns": 211156799, + "success": true + }, + { + "elapsed_ns": 172392, + "end_ns": 221589616, + "in_window": false, + "scheduled_ns": null, + "start_ns": 221417224, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 8904598, + 32610421, + 15406203, + 93623935, + 364857, + 956010, + 964827, + 437865, + 767790 + ], + "failures": 0, + "in_window_samples": 6, + "missed_periods": 13, + "samples": [ + { + "elapsed_ns": 8904598, + "end_ns": 25943786, + "in_window": true, + "scheduled_ns": 17039188, + "start_ns": 25943786, + "success": true + }, + { + "elapsed_ns": 32610421, + "end_ns": 59649609, + "in_window": true, + "scheduled_ns": 27039188, + "start_ns": 59649609, + "success": true + }, + { + "elapsed_ns": 15406203, + "end_ns": 82445391, + "in_window": true, + "scheduled_ns": 67039188, + "start_ns": 82445391, + "success": true + }, + { + "elapsed_ns": 93623935, + "end_ns": 180663123, + "in_window": true, + "scheduled_ns": 87039188, + "start_ns": 180663123, + "success": true + }, + { + "elapsed_ns": 364857, + "end_ns": 187404045, + "in_window": true, + "scheduled_ns": 187039188, + "start_ns": 187404045, + "success": true + }, + { + "elapsed_ns": 956010, + "end_ns": 197995198, + "in_window": true, + "scheduled_ns": 197039188, + "start_ns": 197995198, + "success": true + }, + { + "elapsed_ns": 964827, + "end_ns": 208004015, + "in_window": false, + "scheduled_ns": 207039188, + "start_ns": 208004015, + "success": true + }, + { + "elapsed_ns": 437865, + "end_ns": 217477053, + "in_window": false, + "scheduled_ns": 217039188, + "start_ns": 217477053, + "success": true + }, + { + "elapsed_ns": 767790, + "end_ns": 227806978, + "in_window": false, + "scheduled_ns": 227039188, + "start_ns": 227806978, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 203912264, + "window_start_ns": 7053565 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 1, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 781, + "serialization_ns": 32972, + "serialized_bytes": 613, + "statement_ns": 650580, + "success": true + }, + { + "mutex_wait_ns": 320, + "serialization_ns": 47318, + "serialized_bytes": 613, + "statement_ns": 434180, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 45304, + "serialized_bytes": 1040, + "statement_ns": 355193, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 45685, + "serialized_bytes": 1079, + "statement_ns": 356065, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 46367, + "serialized_bytes": 1087, + "statement_ns": 408943, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 53790, + "serialized_bytes": 1302, + "statement_ns": 519969, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 26980, + "serialized_bytes": 611, + "statement_ns": 451312, + "success": true + }, + { + "mutex_wait_ns": 150, + "serialization_ns": 27411, + "serialized_bytes": 611, + "statement_ns": 380400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 43682, + "serialized_bytes": 1036, + "statement_ns": 377785, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 45916, + "serialized_bytes": 1075, + "statement_ns": 430463, + "success": true + }, + { + "mutex_wait_ns": 301, + "serialization_ns": 67876, + "serialized_bytes": 1083, + "statement_ns": 376803, + "success": true + }, + { + "mutex_wait_ns": 271, + "serialization_ns": 55463, + "serialized_bytes": 1298, + "statement_ns": 398373, + "success": true + }, + { + "mutex_wait_ns": 381, + "serialization_ns": 35096, + "serialized_bytes": 613, + "statement_ns": 449799, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 50504, + "serialized_bytes": 613, + "statement_ns": 384347, + "success": true + }, + { + "mutex_wait_ns": 230, + "serialization_ns": 47719, + "serialized_bytes": 1040, + "statement_ns": 377664, + "success": true + }, + { + "mutex_wait_ns": 281, + "serialization_ns": 45835, + "serialized_bytes": 1079, + "statement_ns": 357918, + "success": true + }, + { + "mutex_wait_ns": 250, + "serialization_ns": 64340, + "serialized_bytes": 1087, + "statement_ns": 375791, + "success": true + }, + { + "mutex_wait_ns": 290, + "serialization_ns": 54101, + "serialized_bytes": 1302, + "statement_ns": 398694, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 26970, + "serialized_bytes": 613, + "statement_ns": 2387042, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 29967, + "serialized_bytes": 613, + "statement_ns": 554264, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 65582, + "serialized_bytes": 1040, + "statement_ns": 497438, + "success": true + }, + { + "mutex_wait_ns": 281, + "serialization_ns": 69660, + "serialized_bytes": 1079, + "statement_ns": 431805, + "success": true + }, + { + "mutex_wait_ns": 290, + "serialization_ns": 67005, + "serialized_bytes": 1087, + "statement_ns": 532613, + "success": true + }, + { + "mutex_wait_ns": 240, + "serialization_ns": 81031, + "serialized_bytes": 1302, + "statement_ns": 403062, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 29435, + "serialized_bytes": 611, + "statement_ns": 492528, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 49282, + "serialized_bytes": 611, + "statement_ns": 365662, + "success": true + }, + { + "mutex_wait_ns": 231, + "serialization_ns": 66263, + "serialized_bytes": 1036, + "statement_ns": 421286, + "success": true + }, + { + "mutex_wait_ns": 290, + "serialization_ns": 48300, + "serialized_bytes": 1075, + "statement_ns": 373467, + "success": true + }, + { + "mutex_wait_ns": 240, + "serialization_ns": 68498, + "serialized_bytes": 1083, + "statement_ns": 418591, + "success": true + }, + { + "mutex_wait_ns": 230, + "serialization_ns": 57468, + "serialized_bytes": 1298, + "statement_ns": 395167, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 29044, + "serialized_bytes": 613, + "statement_ns": 405576, + "success": true + }, + { + "mutex_wait_ns": 331, + "serialization_ns": 54732, + "serialized_bytes": 613, + "statement_ns": 435031, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46056, + "serialized_bytes": 1040, + "statement_ns": 362176, + "success": true + }, + { + "mutex_wait_ns": 281, + "serialization_ns": 46456, + "serialized_bytes": 1079, + "statement_ns": 353289, + "success": true + }, + { + "mutex_wait_ns": 250, + "serialization_ns": 52869, + "serialized_bytes": 1087, + "statement_ns": 362937, + "success": true + }, + { + "mutex_wait_ns": 241, + "serialization_ns": 58449, + "serialized_bytes": 1302, + "statement_ns": 373757, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 28162, + "serialized_bytes": 613, + "statement_ns": 424792, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 48581, + "serialized_bytes": 613, + "statement_ns": 371814, + "success": true + }, + { + "mutex_wait_ns": 240, + "serialization_ns": 65132, + "serialized_bytes": 1040, + "statement_ns": 356155, + "success": true + }, + { + "mutex_wait_ns": 271, + "serialization_ns": 46566, + "serialized_bytes": 1079, + "statement_ns": 365622, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 47398, + "serialized_bytes": 1087, + "statement_ns": 357427, + "success": true + }, + { + "mutex_wait_ns": 260, + "serialization_ns": 55173, + "serialized_bytes": 1302, + "statement_ns": 392703, + "success": true + }, + { + "mutex_wait_ns": 902, + "serialization_ns": 27471, + "serialized_bytes": 611, + "statement_ns": 403613, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 30747, + "serialized_bytes": 611, + "statement_ns": 2263702, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 44383, + "serialized_bytes": 1036, + "statement_ns": 571656, + "success": true + }, + { + "mutex_wait_ns": 280, + "serialization_ns": 68668, + "serialized_bytes": 1075, + "statement_ns": 454638, + "success": true + }, + { + "mutex_wait_ns": 231, + "serialization_ns": 71002, + "serialized_bytes": 1083, + "statement_ns": 411988, + "success": true + }, + { + "mutex_wait_ns": 290, + "serialization_ns": 64210, + "serialized_bytes": 1298, + "statement_ns": 434100, + "success": true + }, + { + "mutex_wait_ns": 370, + "serialization_ns": 28043, + "serialized_bytes": 611, + "statement_ns": 466671, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47779, + "serialized_bytes": 611, + "statement_ns": 393284, + "success": true + }, + { + "mutex_wait_ns": 230, + "serialization_ns": 65262, + "serialized_bytes": 1036, + "statement_ns": 414343, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 48020, + "serialized_bytes": 1075, + "statement_ns": 475748, + "success": true + }, + { + "mutex_wait_ns": 460, + "serialization_ns": 71544, + "serialized_bytes": 1083, + "statement_ns": 368768, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 90018, + "serialized_bytes": 1298, + "statement_ns": 456151, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 28333, + "serialized_bytes": 613, + "statement_ns": 453365, + "success": true + }, + { + "mutex_wait_ns": 231, + "serialization_ns": 49863, + "serialized_bytes": 613, + "statement_ns": 384978, + "success": true + }, + { + "mutex_wait_ns": 260, + "serialization_ns": 62296, + "serialized_bytes": 1040, + "statement_ns": 422107, + "success": true + }, + { + "mutex_wait_ns": 281, + "serialization_ns": 46697, + "serialized_bytes": 1079, + "statement_ns": 368256, + "success": true + }, + { + "mutex_wait_ns": 240, + "serialization_ns": 66775, + "serialized_bytes": 1087, + "statement_ns": 381612, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 59381, + "serialized_bytes": 1302, + "statement_ns": 518356, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 28223, + "serialized_bytes": 613, + "statement_ns": 452864, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 51356, + "serialized_bytes": 613, + "statement_ns": 351195, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 66795, + "serialized_bytes": 1040, + "statement_ns": 406569, + "success": true + }, + { + "mutex_wait_ns": 311, + "serialization_ns": 48651, + "serialized_bytes": 1079, + "statement_ns": 389316, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 67265, + "serialized_bytes": 1087, + "statement_ns": 411067, + "success": true + }, + { + "mutex_wait_ns": 270, + "serialization_ns": 57898, + "serialized_bytes": 1302, + "statement_ns": 398544, + "success": true + }, + { + "mutex_wait_ns": 391, + "serialization_ns": 28543, + "serialized_bytes": 613, + "statement_ns": 411748, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 47539, + "serialized_bytes": 613, + "statement_ns": 359821, + "success": true + }, + { + "mutex_wait_ns": 330, + "serialization_ns": 44634, + "serialized_bytes": 1040, + "statement_ns": 511975, + "success": true + }, + { + "mutex_wait_ns": 251, + "serialization_ns": 49582, + "serialized_bytes": 1079, + "statement_ns": 473974, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 64631, + "serialized_bytes": 1087, + "statement_ns": 403533, + "success": true + }, + { + "mutex_wait_ns": 271, + "serialization_ns": 74859, + "serialized_bytes": 1302, + "statement_ns": 387242, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 26910, + "serialized_bytes": 613, + "statement_ns": 391630, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 48711, + "serialized_bytes": 613, + "statement_ns": 391240, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 49553, + "serialized_bytes": 1040, + "statement_ns": 374859, + "success": true + }, + { + "mutex_wait_ns": 311, + "serialization_ns": 46657, + "serialized_bytes": 1079, + "statement_ns": 370961, + "success": true + }, + { + "mutex_wait_ns": 260, + "serialization_ns": 51817, + "serialized_bytes": 1087, + "statement_ns": 361154, + "success": true + }, + { + "mutex_wait_ns": 280, + "serialization_ns": 55093, + "serialized_bytes": 1302, + "statement_ns": 446193, + "success": true + }, + { + "mutex_wait_ns": 350, + "serialization_ns": 26390, + "serialized_bytes": 611, + "statement_ns": 454949, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 84968, + "serialized_bytes": 611, + "statement_ns": 413020, + "success": true + }, + { + "mutex_wait_ns": 291, + "serialization_ns": 44833, + "serialized_bytes": 1036, + "statement_ns": 409353, + "success": true + }, + { + "mutex_wait_ns": 311, + "serialization_ns": 48670, + "serialized_bytes": 1075, + "statement_ns": 427267, + "success": true + }, + { + "mutex_wait_ns": 301, + "serialization_ns": 66173, + "serialized_bytes": 1083, + "statement_ns": 440451, + "success": true + }, + { + "mutex_wait_ns": 251, + "serialization_ns": 57637, + "serialized_bytes": 1298, + "statement_ns": 465307, + "success": true + }, + { + "mutex_wait_ns": 341, + "serialization_ns": 27080, + "serialized_bytes": 611, + "statement_ns": 456081, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 51345, + "serialized_bytes": 611, + "statement_ns": 459687, + "success": true + }, + { + "mutex_wait_ns": 230, + "serialization_ns": 67786, + "serialized_bytes": 1036, + "statement_ns": 490054, + "success": true + }, + { + "mutex_wait_ns": 291, + "serialization_ns": 48440, + "serialized_bytes": 1075, + "statement_ns": 427597, + "success": true + }, + { + "mutex_wait_ns": 381, + "serialization_ns": 92713, + "serialized_bytes": 1083, + "statement_ns": 421957, + "success": true + }, + { + "mutex_wait_ns": 270, + "serialization_ns": 57507, + "serialized_bytes": 1298, + "statement_ns": 498219, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 27852, + "serialized_bytes": 611, + "statement_ns": 397922, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 48791, + "serialized_bytes": 611, + "statement_ns": 374508, + "success": true + }, + { + "mutex_wait_ns": 261, + "serialization_ns": 67726, + "serialized_bytes": 1036, + "statement_ns": 360042, + "success": true + }, + { + "mutex_wait_ns": 261, + "serialization_ns": 45575, + "serialized_bytes": 1075, + "statement_ns": 371242, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 69440, + "serialized_bytes": 1083, + "statement_ns": 356524, + "success": true + }, + { + "mutex_wait_ns": 231, + "serialization_ns": 55053, + "serialized_bytes": 1298, + "statement_ns": 358749, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 27010, + "serialized_bytes": 613, + "statement_ns": 383535, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 47699, + "serialized_bytes": 613, + "statement_ns": 354572, + "success": true + }, + { + "mutex_wait_ns": 240, + "serialization_ns": 48180, + "serialized_bytes": 1040, + "statement_ns": 442065, + "success": true + }, + { + "mutex_wait_ns": 290, + "serialization_ns": 68217, + "serialized_bytes": 1079, + "statement_ns": 625016, + "success": true + }, + { + "mutex_wait_ns": 240, + "serialization_ns": 67937, + "serialized_bytes": 1087, + "statement_ns": 415225, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 76593, + "serialized_bytes": 1302, + "statement_ns": 546920, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 28272, + "serialized_bytes": 613, + "statement_ns": 448576, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49512, + "serialized_bytes": 613, + "statement_ns": 350013, + "success": true + }, + { + "mutex_wait_ns": 260, + "serialization_ns": 62627, + "serialized_bytes": 1040, + "statement_ns": 391280, + "success": true + }, + { + "mutex_wait_ns": 270, + "serialization_ns": 51977, + "serialized_bytes": 1079, + "statement_ns": 376513, + "success": true + }, + { + "mutex_wait_ns": 241, + "serialization_ns": 66744, + "serialized_bytes": 1087, + "statement_ns": 407029, + "success": true + }, + { + "mutex_wait_ns": 270, + "serialization_ns": 55794, + "serialized_bytes": 1302, + "statement_ns": 404665, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 26630, + "serialized_bytes": 611, + "statement_ns": 418351, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 50474, + "serialized_bytes": 611, + "statement_ns": 357838, + "success": true + }, + { + "mutex_wait_ns": 280, + "serialization_ns": 64631, + "serialized_bytes": 1036, + "statement_ns": 376302, + "success": true + }, + { + "mutex_wait_ns": 271, + "serialization_ns": 45525, + "serialized_bytes": 1075, + "statement_ns": 356605, + "success": true + }, + { + "mutex_wait_ns": 241, + "serialization_ns": 65963, + "serialized_bytes": 1083, + "statement_ns": 373506, + "success": true + }, + { + "mutex_wait_ns": 240, + "serialization_ns": 55093, + "serialized_bytes": 1298, + "statement_ns": 393604, + "success": true + }, + { + "mutex_wait_ns": 401, + "serialization_ns": 27190, + "serialized_bytes": 613, + "statement_ns": 434757, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 33873, + "serialized_bytes": 613, + "statement_ns": 365832, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52999, + "serialized_bytes": 1040, + "statement_ns": 373948, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 55073, + "serialized_bytes": 1079, + "statement_ns": 358929, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 51496, + "serialized_bytes": 1087, + "statement_ns": 356395, + "success": true + }, + { + "mutex_wait_ns": 251, + "serialization_ns": 89246, + "serialized_bytes": 1302, + "statement_ns": 370681, + "success": true + }, + { + "mutex_wait_ns": 391, + "serialization_ns": 28062, + "serialized_bytes": 613, + "statement_ns": 414252, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 28563, + "serialized_bytes": 613, + "statement_ns": 351636, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 44012, + "serialized_bytes": 1040, + "statement_ns": 364049, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 46106, + "serialized_bytes": 1079, + "statement_ns": 400306, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 46888, + "serialized_bytes": 1087, + "statement_ns": 358969, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 54532, + "serialized_bytes": 1302, + "statement_ns": 427778, + "success": true + }, + { + "mutex_wait_ns": 411, + "serialization_ns": 27000, + "serialized_bytes": 613, + "statement_ns": 412169, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 55374, + "serialized_bytes": 613, + "statement_ns": 364470, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 44052, + "serialized_bytes": 1040, + "statement_ns": 357717, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 45735, + "serialized_bytes": 1079, + "statement_ns": 398382, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 46767, + "serialized_bytes": 1087, + "statement_ns": 494663, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 54522, + "serialized_bytes": 1302, + "statement_ns": 546239, + "success": true + }, + { + "mutex_wait_ns": 391, + "serialization_ns": 28202, + "serialized_bytes": 613, + "statement_ns": 486557, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 28834, + "serialized_bytes": 613, + "statement_ns": 365251, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 45986, + "serialized_bytes": 1040, + "statement_ns": 387763, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 48310, + "serialized_bytes": 1079, + "statement_ns": 379067, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 51216, + "serialized_bytes": 1087, + "statement_ns": 431916, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 60243, + "serialized_bytes": 1302, + "statement_ns": 440622, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 27872, + "serialized_bytes": 613, + "statement_ns": 429230, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 28463, + "serialized_bytes": 613, + "statement_ns": 344663, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 43932, + "serialized_bytes": 1040, + "statement_ns": 397822, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 53560, + "serialized_bytes": 1079, + "statement_ns": 370391, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 48320, + "serialized_bytes": 1087, + "statement_ns": 363868, + "success": true + }, + { + "mutex_wait_ns": 280, + "serialization_ns": 87573, + "serialized_bytes": 1302, + "statement_ns": 392482, + "success": true + }, + { + "mutex_wait_ns": 401, + "serialization_ns": 27712, + "serialized_bytes": 613, + "statement_ns": 402541, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 28333, + "serialized_bytes": 613, + "statement_ns": 343000, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 43862, + "serialized_bytes": 1040, + "statement_ns": 365611, + "success": true + }, + { + "mutex_wait_ns": 1813, + "serialization_ns": 79108, + "serialized_bytes": 1079, + "statement_ns": 377925, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 46687, + "serialized_bytes": 1087, + "statement_ns": 358348, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 54311, + "serialized_bytes": 1302, + "statement_ns": 461330, + "success": true + }, + { + "mutex_wait_ns": 370, + "serialization_ns": 26790, + "serialized_bytes": 613, + "statement_ns": 413221, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 27822, + "serialized_bytes": 613, + "statement_ns": 354541, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 44112, + "serialized_bytes": 1040, + "statement_ns": 355954, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 46025, + "serialized_bytes": 1079, + "statement_ns": 389867, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 48710, + "serialized_bytes": 1087, + "statement_ns": 352077, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 56706, + "serialized_bytes": 1302, + "statement_ns": 385639, + "success": true + }, + { + "mutex_wait_ns": 381, + "serialization_ns": 27491, + "serialized_bytes": 611, + "statement_ns": 413391, + "success": true + }, + { + "mutex_wait_ns": 161, + "serialization_ns": 27611, + "serialized_bytes": 611, + "statement_ns": 341076, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 43591, + "serialized_bytes": 1036, + "statement_ns": 375941, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 45054, + "serialized_bytes": 1075, + "statement_ns": 348280, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 46166, + "serialized_bytes": 1083, + "statement_ns": 347368, + "success": true + }, + { + "mutex_wait_ns": 271, + "serialization_ns": 83876, + "serialized_bytes": 1298, + "statement_ns": 556337, + "success": true + }, + { + "mutex_wait_ns": 380, + "serialization_ns": 27221, + "serialized_bytes": 613, + "statement_ns": 417379, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 27552, + "serialized_bytes": 613, + "statement_ns": 343821, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 43912, + "serialized_bytes": 1040, + "statement_ns": 389726, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 46387, + "serialized_bytes": 1079, + "statement_ns": 363619, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 49001, + "serialized_bytes": 1087, + "statement_ns": 367255, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 56926, + "serialized_bytes": 1302, + "statement_ns": 347678, + "success": true + }, + { + "mutex_wait_ns": 381, + "serialization_ns": 28483, + "serialized_bytes": 613, + "statement_ns": 389557, + "success": true + }, + { + "mutex_wait_ns": 141, + "serialization_ns": 26860, + "serialized_bytes": 613, + "statement_ns": 333592, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 43311, + "serialized_bytes": 1040, + "statement_ns": 395668, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 46086, + "serialized_bytes": 1079, + "statement_ns": 361514, + "success": true + }, + { + "mutex_wait_ns": 270, + "serialization_ns": 71474, + "serialized_bytes": 1087, + "statement_ns": 397060, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 54923, + "serialized_bytes": 1302, + "statement_ns": 381822, + "success": true + }, + { + "mutex_wait_ns": 370, + "serialization_ns": 27782, + "serialized_bytes": 613, + "statement_ns": 408572, + "success": true + }, + { + "mutex_wait_ns": 161, + "serialization_ns": 28292, + "serialized_bytes": 613, + "statement_ns": 335586, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 43901, + "serialized_bytes": 1040, + "statement_ns": 352267, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 46337, + "serialized_bytes": 1079, + "statement_ns": 352348, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 48651, + "serialized_bytes": 1087, + "statement_ns": 423289, + "success": true + }, + { + "mutex_wait_ns": 240, + "serialization_ns": 57758, + "serialized_bytes": 1302, + "statement_ns": 452093, + "success": true + }, + { + "mutex_wait_ns": 481, + "serialization_ns": 33402, + "serialized_bytes": 613, + "statement_ns": 480085, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 29365, + "serialized_bytes": 613, + "statement_ns": 442365, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46377, + "serialized_bytes": 1040, + "statement_ns": 423019, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 46277, + "serialized_bytes": 1079, + "statement_ns": 364840, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 46527, + "serialized_bytes": 1087, + "statement_ns": 441403, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 55263, + "serialized_bytes": 1302, + "statement_ns": 407530, + "success": true + }, + { + "mutex_wait_ns": 391, + "serialization_ns": 27962, + "serialized_bytes": 611, + "statement_ns": 493280, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 31048, + "serialized_bytes": 611, + "statement_ns": 366784, + "success": true + }, + { + "mutex_wait_ns": 260, + "serialization_ns": 48180, + "serialized_bytes": 1036, + "statement_ns": 461501, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 48541, + "serialized_bytes": 1075, + "statement_ns": 365405, + "success": true + }, + { + "mutex_wait_ns": 581, + "serialization_ns": 77355, + "serialized_bytes": 1083, + "statement_ns": 447845, + "success": true + }, + { + "mutex_wait_ns": 281, + "serialization_ns": 66834, + "serialized_bytes": 1298, + "statement_ns": 607493, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 1995591, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=1", + "COMPILER=gcc-11.4.0", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_PTHREADS", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "TLS", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 198527471, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 173627852, + 175949011, + 175838314, + 175725364, + 175610480, + 176729016, + 175518187, + 175400468, + 176624982, + 175334094, + 175217577, + 175100268, + 174984072, + 174818212, + 174754674, + 174644859, + 174533111, + 174416853, + 174299625, + 174155206, + 174037065, + 173921038, + 173804451, + 173673437, + 173535720, + 173414534, + 173297205, + 173180107, + 173063379, + 173032011, + 190222682, + 192978583 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 5033137, + 11853998, + 26099177, + 83848272, + 3484168, + 206014, + 155630, + 193791, + 170869 + ], + "failures": 0, + "in_window_samples": 7, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 5033137, + "end_ns": 18061710, + "in_window": true, + "scheduled_ns": null, + "start_ns": 13028573, + "success": true + }, + { + "elapsed_ns": 11853998, + "end_ns": 39992152, + "in_window": true, + "scheduled_ns": null, + "start_ns": 28138154, + "success": true + }, + { + "elapsed_ns": 26099177, + "end_ns": 76164876, + "in_window": true, + "scheduled_ns": null, + "start_ns": 50065699, + "success": true + }, + { + "elapsed_ns": 83848272, + "end_ns": 170081285, + "in_window": true, + "scheduled_ns": null, + "start_ns": 86233013, + "success": true + }, + { + "elapsed_ns": 3484168, + "end_ns": 183643509, + "in_window": true, + "scheduled_ns": null, + "start_ns": 180159341, + "success": true + }, + { + "elapsed_ns": 206014, + "end_ns": 193928481, + "in_window": true, + "scheduled_ns": null, + "start_ns": 193722467, + "success": true + }, + { + "elapsed_ns": 155630, + "end_ns": 204162348, + "in_window": true, + "scheduled_ns": null, + "start_ns": 204006718, + "success": true + }, + { + "elapsed_ns": 193791, + "end_ns": 214430238, + "in_window": false, + "scheduled_ns": null, + "start_ns": 214236447, + "success": true + }, + { + "elapsed_ns": 170869, + "end_ns": 224654407, + "in_window": false, + "scheduled_ns": null, + "start_ns": 224483538, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 18983927, + 40532547, + 96627096, + 1424112, + 948456, + 1626321, + 1438210, + 1750817 + ], + "failures": 0, + "in_window_samples": 5, + "missed_periods": 14, + "samples": [ + { + "elapsed_ns": 18983927, + "end_ns": 36103996, + "in_window": true, + "scheduled_ns": 17120069, + "start_ns": 36103996, + "success": true + }, + { + "elapsed_ns": 40532547, + "end_ns": 77652616, + "in_window": true, + "scheduled_ns": 37120069, + "start_ns": 77652616, + "success": true + }, + { + "elapsed_ns": 96627096, + "end_ns": 183747165, + "in_window": true, + "scheduled_ns": 87120069, + "start_ns": 183747165, + "success": true + }, + { + "elapsed_ns": 1424112, + "end_ns": 188544181, + "in_window": true, + "scheduled_ns": 187120069, + "start_ns": 188544181, + "success": true + }, + { + "elapsed_ns": 948456, + "end_ns": 198068525, + "in_window": true, + "scheduled_ns": 197120069, + "start_ns": 198068525, + "success": true + }, + { + "elapsed_ns": 1626321, + "end_ns": 208746390, + "in_window": false, + "scheduled_ns": 207120069, + "start_ns": 208746390, + "success": true + }, + { + "elapsed_ns": 1438210, + "end_ns": 218558279, + "in_window": false, + "scheduled_ns": 217120069, + "start_ns": 218558279, + "success": true + }, + { + "elapsed_ns": 1750817, + "end_ns": 228870886, + "in_window": false, + "scheduled_ns": 227120069, + "start_ns": 228870886, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 205661426, + "window_start_ns": 7133955 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 2, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 762, + "serialization_ns": 32901, + "serialized_bytes": 613, + "statement_ns": 3650007, + "success": true + }, + { + "mutex_wait_ns": 491, + "serialization_ns": 62968, + "serialized_bytes": 613, + "statement_ns": 503739, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 45775, + "serialized_bytes": 1040, + "statement_ns": 401048, + "success": true + }, + { + "mutex_wait_ns": 241, + "serialization_ns": 46166, + "serialized_bytes": 1079, + "statement_ns": 427006, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 46948, + "serialized_bytes": 1087, + "statement_ns": 445881, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 54201, + "serialized_bytes": 1302, + "statement_ns": 560566, + "success": true + }, + { + "mutex_wait_ns": 381, + "serialization_ns": 27471, + "serialized_bytes": 611, + "statement_ns": 531030, + "success": true + }, + { + "mutex_wait_ns": 161, + "serialization_ns": 27782, + "serialized_bytes": 611, + "statement_ns": 399385, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 44553, + "serialized_bytes": 1036, + "statement_ns": 357768, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 47950, + "serialized_bytes": 1075, + "statement_ns": 375240, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 48801, + "serialized_bytes": 1083, + "statement_ns": 411517, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 56937, + "serialized_bytes": 1298, + "statement_ns": 370551, + "success": true + }, + { + "mutex_wait_ns": 360, + "serialization_ns": 27882, + "serialized_bytes": 613, + "statement_ns": 557480, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 27471, + "serialized_bytes": 613, + "statement_ns": 376663, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 43831, + "serialized_bytes": 1040, + "statement_ns": 335747, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46136, + "serialized_bytes": 1079, + "statement_ns": 408332, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 46457, + "serialized_bytes": 1087, + "statement_ns": 343540, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 53980, + "serialized_bytes": 1302, + "statement_ns": 732796, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 26650, + "serialized_bytes": 613, + "statement_ns": 859473, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 27381, + "serialized_bytes": 613, + "statement_ns": 456251, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 44243, + "serialized_bytes": 1040, + "statement_ns": 712609, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 46497, + "serialized_bytes": 1079, + "statement_ns": 799231, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 47027, + "serialized_bytes": 1087, + "statement_ns": 413672, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 57177, + "serialized_bytes": 1302, + "statement_ns": 804911, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 27942, + "serialized_bytes": 613, + "statement_ns": 725593, + "success": true + }, + { + "mutex_wait_ns": 161, + "serialization_ns": 30126, + "serialized_bytes": 613, + "statement_ns": 385659, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 48871, + "serialized_bytes": 1040, + "statement_ns": 490835, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 51395, + "serialized_bytes": 1079, + "statement_ns": 370551, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 51576, + "serialized_bytes": 1087, + "statement_ns": 573690, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 65272, + "serialized_bytes": 1302, + "statement_ns": 449067, + "success": true + }, + { + "mutex_wait_ns": 370, + "serialization_ns": 31810, + "serialized_bytes": 611, + "statement_ns": 888517, + "success": true + }, + { + "mutex_wait_ns": 161, + "serialization_ns": 32210, + "serialized_bytes": 611, + "statement_ns": 861767, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 57256, + "serialized_bytes": 1036, + "statement_ns": 861326, + "success": true + }, + { + "mutex_wait_ns": 230, + "serialization_ns": 63578, + "serialized_bytes": 1075, + "statement_ns": 366424, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 59912, + "serialized_bytes": 1083, + "statement_ns": 788020, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 71092, + "serialized_bytes": 1298, + "statement_ns": 502086, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 31468, + "serialized_bytes": 613, + "statement_ns": 617101, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 34745, + "serialized_bytes": 613, + "statement_ns": 539767, + "success": true + }, + { + "mutex_wait_ns": 161, + "serialization_ns": 55073, + "serialized_bytes": 1040, + "statement_ns": 408201, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 55143, + "serialized_bytes": 1079, + "statement_ns": 986860, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 55484, + "serialized_bytes": 1087, + "statement_ns": 433117, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 70942, + "serialized_bytes": 1302, + "statement_ns": 908384, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 64831, + "serialized_bytes": 613, + "statement_ns": 414313, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 32090, + "serialized_bytes": 613, + "statement_ns": 658158, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 57206, + "serialized_bytes": 1040, + "statement_ns": 493060, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 59702, + "serialized_bytes": 1079, + "statement_ns": 839436, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 60323, + "serialized_bytes": 1087, + "statement_ns": 392652, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 71183, + "serialized_bytes": 1302, + "statement_ns": 411267, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 34274, + "serialized_bytes": 611, + "statement_ns": 473753, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 34624, + "serialized_bytes": 611, + "statement_ns": 792518, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 48701, + "serialized_bytes": 1036, + "statement_ns": 382734, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 54572, + "serialized_bytes": 1075, + "statement_ns": 975429, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 55243, + "serialized_bytes": 1083, + "statement_ns": 568761, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 65151, + "serialized_bytes": 1298, + "statement_ns": 447004, + "success": true + }, + { + "mutex_wait_ns": 360, + "serialization_ns": 31830, + "serialized_bytes": 613, + "statement_ns": 830850, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 27721, + "serialized_bytes": 613, + "statement_ns": 406498, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 44062, + "serialized_bytes": 1040, + "statement_ns": 699194, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48451, + "serialized_bytes": 1079, + "statement_ns": 398954, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58219, + "serialized_bytes": 1087, + "statement_ns": 600460, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 57046, + "serialized_bytes": 1302, + "statement_ns": 784252, + "success": true + }, + { + "mutex_wait_ns": 370, + "serialization_ns": 29485, + "serialized_bytes": 611, + "statement_ns": 389497, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 29846, + "serialized_bytes": 611, + "statement_ns": 427768, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 48811, + "serialized_bytes": 1036, + "statement_ns": 337730, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 50995, + "serialized_bytes": 1075, + "statement_ns": 350914, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 51436, + "serialized_bytes": 1083, + "statement_ns": 330637, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 60363, + "serialized_bytes": 1298, + "statement_ns": 413852, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 27100, + "serialized_bytes": 613, + "statement_ns": 357116, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 27300, + "serialized_bytes": 613, + "statement_ns": 367756, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 44363, + "serialized_bytes": 1040, + "statement_ns": 324635, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46307, + "serialized_bytes": 1079, + "statement_ns": 335606, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 46536, + "serialized_bytes": 1087, + "statement_ns": 447114, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 54662, + "serialized_bytes": 1302, + "statement_ns": 464386, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 28013, + "serialized_bytes": 613, + "statement_ns": 496916, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 33292, + "serialized_bytes": 613, + "statement_ns": 744849, + "success": true + }, + { + "mutex_wait_ns": 241, + "serialization_ns": 46968, + "serialized_bytes": 1040, + "statement_ns": 503699, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 50995, + "serialized_bytes": 1079, + "statement_ns": 521122, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 51416, + "serialized_bytes": 1087, + "statement_ns": 377575, + "success": true + }, + { + "mutex_wait_ns": 241, + "serialization_ns": 60713, + "serialized_bytes": 1302, + "statement_ns": 374428, + "success": true + }, + { + "mutex_wait_ns": 441, + "serialization_ns": 31538, + "serialized_bytes": 613, + "statement_ns": 616837, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 35726, + "serialized_bytes": 613, + "statement_ns": 509971, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 57648, + "serialized_bytes": 1040, + "statement_ns": 430753, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 55012, + "serialized_bytes": 1079, + "statement_ns": 352677, + "success": true + }, + { + "mutex_wait_ns": 251, + "serialization_ns": 79889, + "serialized_bytes": 1087, + "statement_ns": 347879, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 60793, + "serialized_bytes": 1302, + "statement_ns": 343580, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 29705, + "serialized_bytes": 613, + "statement_ns": 366093, + "success": true + }, + { + "mutex_wait_ns": 140, + "serialization_ns": 28694, + "serialized_bytes": 613, + "statement_ns": 304578, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 45985, + "serialized_bytes": 1040, + "statement_ns": 360263, + "success": true + }, + { + "mutex_wait_ns": 260, + "serialization_ns": 46226, + "serialized_bytes": 1079, + "statement_ns": 319546, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 47569, + "serialized_bytes": 1087, + "statement_ns": 335677, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 57216, + "serialized_bytes": 1302, + "statement_ns": 386050, + "success": true + }, + { + "mutex_wait_ns": 350, + "serialization_ns": 28063, + "serialized_bytes": 613, + "statement_ns": 436314, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 35546, + "serialized_bytes": 613, + "statement_ns": 332560, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 45675, + "serialized_bytes": 1040, + "statement_ns": 321629, + "success": true + }, + { + "mutex_wait_ns": 291, + "serialization_ns": 46907, + "serialized_bytes": 1079, + "statement_ns": 348329, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 46797, + "serialized_bytes": 1087, + "statement_ns": 325326, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 63879, + "serialized_bytes": 1302, + "statement_ns": 366664, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 26930, + "serialized_bytes": 613, + "statement_ns": 354861, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 27261, + "serialized_bytes": 613, + "statement_ns": 347999, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 44183, + "serialized_bytes": 1040, + "statement_ns": 319256, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 46177, + "serialized_bytes": 1079, + "statement_ns": 368237, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 46266, + "serialized_bytes": 1087, + "statement_ns": 354731, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 53720, + "serialized_bytes": 1302, + "statement_ns": 347127, + "success": true + }, + { + "mutex_wait_ns": 370, + "serialization_ns": 26480, + "serialized_bytes": 611, + "statement_ns": 364991, + "success": true + }, + { + "mutex_wait_ns": 131, + "serialization_ns": 28172, + "serialized_bytes": 611, + "statement_ns": 301081, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 43892, + "serialized_bytes": 1036, + "statement_ns": 362656, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 46156, + "serialized_bytes": 1075, + "statement_ns": 325938, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 49943, + "serialized_bytes": 1083, + "statement_ns": 372284, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 53480, + "serialized_bytes": 1298, + "statement_ns": 332380, + "success": true + }, + { + "mutex_wait_ns": 381, + "serialization_ns": 27050, + "serialized_bytes": 613, + "statement_ns": 379638, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 27762, + "serialized_bytes": 613, + "statement_ns": 314476, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 43561, + "serialized_bytes": 1040, + "statement_ns": 311130, + "success": true + }, + { + "mutex_wait_ns": 230, + "serialization_ns": 46016, + "serialized_bytes": 1079, + "statement_ns": 355704, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46798, + "serialized_bytes": 1087, + "statement_ns": 317432, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 54632, + "serialized_bytes": 1302, + "statement_ns": 492379, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 27011, + "serialized_bytes": 613, + "statement_ns": 430102, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 55654, + "serialized_bytes": 613, + "statement_ns": 358629, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 47508, + "serialized_bytes": 1040, + "statement_ns": 331869, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 48230, + "serialized_bytes": 1079, + "statement_ns": 348340, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 48620, + "serialized_bytes": 1087, + "statement_ns": 344172, + "success": true + }, + { + "mutex_wait_ns": 251, + "serialization_ns": 56916, + "serialized_bytes": 1302, + "statement_ns": 338091, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 26499, + "serialized_bytes": 611, + "statement_ns": 354251, + "success": true + }, + { + "mutex_wait_ns": 151, + "serialization_ns": 26920, + "serialized_bytes": 611, + "statement_ns": 347548, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 43270, + "serialized_bytes": 1036, + "statement_ns": 342118, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 45114, + "serialized_bytes": 1075, + "statement_ns": 356846, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 45745, + "serialized_bytes": 1083, + "statement_ns": 366514, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53630, + "serialized_bytes": 1298, + "statement_ns": 348851, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 26830, + "serialized_bytes": 611, + "statement_ns": 384708, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 27471, + "serialized_bytes": 611, + "statement_ns": 303746, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 43732, + "serialized_bytes": 1036, + "statement_ns": 370541, + "success": true + }, + { + "mutex_wait_ns": 240, + "serialization_ns": 45054, + "serialized_bytes": 1075, + "statement_ns": 324045, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 45706, + "serialized_bytes": 1083, + "statement_ns": 319676, + "success": true + }, + { + "mutex_wait_ns": 321, + "serialization_ns": 80840, + "serialized_bytes": 1298, + "statement_ns": 368938, + "success": true + }, + { + "mutex_wait_ns": 381, + "serialization_ns": 26469, + "serialized_bytes": 613, + "statement_ns": 340485, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 54282, + "serialized_bytes": 613, + "statement_ns": 319716, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 43080, + "serialized_bytes": 1040, + "statement_ns": 313575, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 45264, + "serialized_bytes": 1079, + "statement_ns": 340354, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 45935, + "serialized_bytes": 1087, + "statement_ns": 316431, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 53620, + "serialized_bytes": 1302, + "statement_ns": 355373, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 26459, + "serialized_bytes": 613, + "statement_ns": 396780, + "success": true + }, + { + "mutex_wait_ns": 151, + "serialization_ns": 27030, + "serialized_bytes": 613, + "statement_ns": 306060, + "success": true + }, + { + "mutex_wait_ns": 291, + "serialization_ns": 71754, + "serialized_bytes": 1040, + "statement_ns": 332700, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 45295, + "serialized_bytes": 1079, + "statement_ns": 320558, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 48851, + "serialized_bytes": 1087, + "statement_ns": 343060, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53369, + "serialized_bytes": 1302, + "statement_ns": 324746, + "success": true + }, + { + "mutex_wait_ns": 411, + "serialization_ns": 32150, + "serialized_bytes": 613, + "statement_ns": 359220, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 27111, + "serialized_bytes": 613, + "statement_ns": 307223, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 43061, + "serialized_bytes": 1040, + "statement_ns": 313945, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 44964, + "serialized_bytes": 1079, + "statement_ns": 368568, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 45775, + "serialized_bytes": 1087, + "statement_ns": 336408, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 54301, + "serialized_bytes": 1302, + "statement_ns": 515992, + "success": true + }, + { + "mutex_wait_ns": 380, + "serialization_ns": 26570, + "serialized_bytes": 613, + "statement_ns": 372525, + "success": true + }, + { + "mutex_wait_ns": 291, + "serialization_ns": 53450, + "serialized_bytes": 613, + "statement_ns": 347127, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 44232, + "serialized_bytes": 1040, + "statement_ns": 318173, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 46677, + "serialized_bytes": 1079, + "statement_ns": 351295, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 46677, + "serialized_bytes": 1087, + "statement_ns": 342910, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 54281, + "serialized_bytes": 1302, + "statement_ns": 318074, + "success": true + }, + { + "mutex_wait_ns": 370, + "serialization_ns": 27051, + "serialized_bytes": 613, + "statement_ns": 406589, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 27521, + "serialized_bytes": 613, + "statement_ns": 317332, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 42960, + "serialized_bytes": 1040, + "statement_ns": 311922, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 45135, + "serialized_bytes": 1079, + "statement_ns": 365652, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 46026, + "serialized_bytes": 1087, + "statement_ns": 317933, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 53329, + "serialized_bytes": 1302, + "statement_ns": 358658, + "success": true + }, + { + "mutex_wait_ns": 381, + "serialization_ns": 27070, + "serialized_bytes": 613, + "statement_ns": 343030, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 27001, + "serialized_bytes": 613, + "statement_ns": 315238, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 43121, + "serialized_bytes": 1040, + "statement_ns": 318404, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 45024, + "serialized_bytes": 1079, + "statement_ns": 314036, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 46337, + "serialized_bytes": 1087, + "statement_ns": 362376, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53470, + "serialized_bytes": 1302, + "statement_ns": 338872, + "success": true + }, + { + "mutex_wait_ns": 411, + "serialization_ns": 26980, + "serialized_bytes": 611, + "statement_ns": 376883, + "success": true + }, + { + "mutex_wait_ns": 150, + "serialization_ns": 27091, + "serialized_bytes": 611, + "statement_ns": 319045, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 43031, + "serialized_bytes": 1036, + "statement_ns": 334283, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 45174, + "serialized_bytes": 1075, + "statement_ns": 320347, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 45585, + "serialized_bytes": 1083, + "statement_ns": 310950, + "success": true + }, + { + "mutex_wait_ns": 260, + "serialization_ns": 93214, + "serialized_bytes": 1298, + "statement_ns": 375060, + "success": true + }, + { + "mutex_wait_ns": 421, + "serialization_ns": 26509, + "serialized_bytes": 611, + "statement_ns": 370281, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 26950, + "serialized_bytes": 611, + "statement_ns": 318965, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 43080, + "serialized_bytes": 1036, + "statement_ns": 330255, + "success": true + }, + { + "mutex_wait_ns": 281, + "serialization_ns": 71443, + "serialized_bytes": 1075, + "statement_ns": 330516, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 45535, + "serialized_bytes": 1083, + "statement_ns": 317693, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 54141, + "serialized_bytes": 1298, + "statement_ns": 322011, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 26409, + "serialized_bytes": 613, + "statement_ns": 350504, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 27662, + "serialized_bytes": 613, + "statement_ns": 330917, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 42980, + "serialized_bytes": 1040, + "statement_ns": 2999013, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 46026, + "serialized_bytes": 1079, + "statement_ns": 687633, + "success": true + }, + { + "mutex_wait_ns": 280, + "serialization_ns": 87884, + "serialized_bytes": 1087, + "statement_ns": 430764, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 56886, + "serialized_bytes": 1302, + "statement_ns": 403753, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 28112, + "serialized_bytes": 611, + "statement_ns": 375039, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 28484, + "serialized_bytes": 611, + "statement_ns": 314256, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 45535, + "serialized_bytes": 1036, + "statement_ns": 341878, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 45184, + "serialized_bytes": 1075, + "statement_ns": 355153, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 46948, + "serialized_bytes": 1083, + "statement_ns": 384987, + "success": true + }, + { + "mutex_wait_ns": 240, + "serialization_ns": 54622, + "serialized_bytes": 1298, + "statement_ns": 346747, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 2031088, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=1", + "COMPILER=gcc-11.4.0", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_PTHREADS", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "TLS", + "wall_budget_exceeded": false + } + ], + "not_run": { + "disk_flush_count": "not observed", + "gui_android": "outside harness", + "production_performance": "synthetic test-only harness", + "queue_wait": "no writer queue exists", + "sqlite_busy_wait_separate": "included in statement elapsed" + }, + "profile": "debug", + "runtime": "current_thread", + "schema": 1, + "status": "PASS", + "timer_network_positive_control": { + "detector_threshold_ms": 100, + "injected_block_ms": 300, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 294737189, + 225561, + 179916 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 294737189, + "end_ns": 307684513, + "in_window": true, + "scheduled_ns": null, + "start_ns": 12947324, + "success": true + }, + { + "elapsed_ns": 225561, + "end_ns": 318022624, + "in_window": false, + "scheduled_ns": null, + "start_ns": 317797063, + "success": true + }, + { + "elapsed_ns": 179916, + "end_ns": 328308919, + "in_window": false, + "scheduled_ns": null, + "start_ns": 328129003, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 290473045, + 845671, + 1005090 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 29, + "samples": [ + { + "elapsed_ns": 290473045, + "end_ns": 307658657, + "in_window": true, + "scheduled_ns": 17185612, + "start_ns": 307658657, + "success": true + }, + { + "elapsed_ns": 845671, + "end_ns": 318031283, + "in_window": false, + "scheduled_ns": 317185612, + "start_ns": 318031283, + "success": true + }, + { + "elapsed_ns": 1005090, + "end_ns": 328190702, + "in_window": false, + "scheduled_ns": 327185612, + "start_ns": 328190702, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 307329233, + "window_start_ns": 7199377 + }, + "status": "PASS" + }, + "workers": 0 + }, + "cleanup_uncertain": false + }, + { + "profile": "debug", + "workers": 2, + "status": "PASS", + "reason": null, + "report": { + "cases": [ + { + "batch_elapsed_ns": 85189753, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 77912598, + 79143437, + 80733766, + 79346479, + 81114803, + 79721484, + 81371465, + 79938743, + 81743205, + 80304503, + 82940839, + 81430870, + 83246432, + 83032591, + 81916108, + 81616139, + 81868111, + 80975851, + 82518424, + 80965067, + 83044773, + 82789957, + 81539626, + 81245247, + 83345271, + 82926005, + 81853598, + 81405299, + 83528135, + 81519618, + 82027686, + 83748816 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 74450574, + 206445, + 130022 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 74450574, + "end_ns": 84955766, + "in_window": true, + "scheduled_ns": null, + "start_ns": 10505192, + "success": true + }, + { + "elapsed_ns": 206445, + "end_ns": 95246739, + "in_window": false, + "scheduled_ns": null, + "start_ns": 95040294, + "success": true + }, + { + "elapsed_ns": 130022, + "end_ns": 105450480, + "in_window": false, + "scheduled_ns": null, + "start_ns": 105320458, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 38410709, + 33966542, + 1261535, + 798551, + 1109181 + ], + "failures": 0, + "in_window_samples": 2, + "missed_periods": 6, + "samples": [ + { + "elapsed_ns": 38410709, + "end_ns": 49970113, + "in_window": true, + "scheduled_ns": 11559404, + "start_ns": 49970113, + "success": true + }, + { + "elapsed_ns": 33966542, + "end_ns": 85525946, + "in_window": true, + "scheduled_ns": 51559404, + "start_ns": 85525946, + "success": true + }, + { + "elapsed_ns": 1261535, + "end_ns": 92820939, + "in_window": false, + "scheduled_ns": 91559404, + "start_ns": 92820939, + "success": true + }, + { + "elapsed_ns": 798551, + "end_ns": 102357955, + "in_window": false, + "scheduled_ns": 101559404, + "start_ns": 102357955, + "success": true + }, + { + "elapsed_ns": 1109181, + "end_ns": 112668585, + "in_window": false, + "scheduled_ns": 111559404, + "start_ns": 112668585, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 86766745, + "window_start_ns": 1576992 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 0, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 481, + "serialization_ns": 29284, + "serialized_bytes": 612, + "statement_ns": 564263, + "success": true + }, + { + "mutex_wait_ns": 161, + "serialization_ns": 28402, + "serialized_bytes": 612, + "statement_ns": 404905, + "success": true + }, + { + "mutex_wait_ns": 150, + "serialization_ns": 44362, + "serialized_bytes": 1038, + "statement_ns": 385329, + "success": true + }, + { + "mutex_wait_ns": 411, + "serialization_ns": 57196, + "serialized_bytes": 610, + "statement_ns": 477731, + "success": true + }, + { + "mutex_wait_ns": 433980, + "serialization_ns": 45855, + "serialized_bytes": 1077, + "statement_ns": 417469, + "success": true + }, + { + "mutex_wait_ns": 401539, + "serialization_ns": 27571, + "serialized_bytes": 610, + "statement_ns": 400220, + "success": true + }, + { + "mutex_wait_ns": 324091, + "serialization_ns": 78797, + "serialized_bytes": 1085, + "statement_ns": 359872, + "success": true + }, + { + "mutex_wait_ns": 307533, + "serialization_ns": 50174, + "serialized_bytes": 1034, + "statement_ns": 357056, + "success": true + }, + { + "mutex_wait_ns": 296974, + "serialization_ns": 54311, + "serialized_bytes": 1300, + "statement_ns": 342860, + "success": true + }, + { + "mutex_wait_ns": 285422, + "serialization_ns": 45796, + "serialized_bytes": 1073, + "statement_ns": 389757, + "success": true + }, + { + "mutex_wait_ns": 126185, + "serialization_ns": 46297, + "serialized_bytes": 612, + "statement_ns": 415024, + "success": true + }, + { + "mutex_wait_ns": 359626, + "serialization_ns": 64400, + "serialized_bytes": 1081, + "statement_ns": 389088, + "success": true + }, + { + "mutex_wait_ns": 354194, + "serialization_ns": 47909, + "serialized_bytes": 612, + "statement_ns": 377745, + "success": true + }, + { + "mutex_wait_ns": 317472, + "serialization_ns": 59791, + "serialized_bytes": 1296, + "statement_ns": 422128, + "success": true + }, + { + "mutex_wait_ns": 377775, + "serialization_ns": 44032, + "serialized_bytes": 1038, + "statement_ns": 413942, + "success": true + }, + { + "mutex_wait_ns": 177281, + "serialization_ns": 32611, + "serialized_bytes": 612, + "statement_ns": 496606, + "success": true + }, + { + "mutex_wait_ns": 404594, + "serialization_ns": 51647, + "serialized_bytes": 1077, + "statement_ns": 590110, + "success": true + }, + { + "mutex_wait_ns": 578029, + "serialization_ns": 27982, + "serialized_bytes": 612, + "statement_ns": 372985, + "success": true + }, + { + "mutex_wait_ns": 333953, + "serialization_ns": 46096, + "serialized_bytes": 1085, + "statement_ns": 345454, + "success": true + }, + { + "mutex_wait_ns": 302755, + "serialization_ns": 43571, + "serialized_bytes": 1038, + "statement_ns": 364539, + "success": true + }, + { + "mutex_wait_ns": 299238, + "serialization_ns": 54562, + "serialized_bytes": 1300, + "statement_ns": 413261, + "success": true + }, + { + "mutex_wait_ns": 336407, + "serialization_ns": 59832, + "serialized_bytes": 1077, + "statement_ns": 394576, + "success": true + }, + { + "mutex_wait_ns": 156332, + "serialization_ns": 28683, + "serialized_bytes": 610, + "statement_ns": 435432, + "success": true + }, + { + "mutex_wait_ns": 402420, + "serialization_ns": 46287, + "serialized_bytes": 1085, + "statement_ns": 373867, + "success": true + }, + { + "mutex_wait_ns": 355202, + "serialization_ns": 28794, + "serialized_bytes": 610, + "statement_ns": 416898, + "success": true + }, + { + "mutex_wait_ns": 358709, + "serialization_ns": 54622, + "serialized_bytes": 1300, + "statement_ns": 381391, + "success": true + }, + { + "mutex_wait_ns": 344172, + "serialization_ns": 46116, + "serialized_bytes": 1034, + "statement_ns": 445390, + "success": true + }, + { + "mutex_wait_ns": 231893, + "serialization_ns": 27501, + "serialized_bytes": 612, + "statement_ns": 471509, + "success": true + }, + { + "mutex_wait_ns": 413612, + "serialization_ns": 48410, + "serialized_bytes": 1073, + "statement_ns": 406839, + "success": true + }, + { + "mutex_wait_ns": 394395, + "serialization_ns": 28744, + "serialized_bytes": 612, + "statement_ns": 338732, + "success": true + }, + { + "mutex_wait_ns": 295261, + "serialization_ns": 51926, + "serialized_bytes": 1081, + "statement_ns": 336798, + "success": true + }, + { + "mutex_wait_ns": 291624, + "serialization_ns": 46367, + "serialized_bytes": 1038, + "statement_ns": 370651, + "success": true + }, + { + "mutex_wait_ns": 301692, + "serialization_ns": 65052, + "serialized_bytes": 1296, + "statement_ns": 466771, + "success": true + }, + { + "mutex_wait_ns": 405857, + "serialization_ns": 50945, + "serialized_bytes": 1077, + "statement_ns": 398854, + "success": true + }, + { + "mutex_wait_ns": 143708, + "serialization_ns": 29936, + "serialized_bytes": 612, + "statement_ns": 405466, + "success": true + }, + { + "mutex_wait_ns": 359751, + "serialization_ns": 55464, + "serialized_bytes": 1085, + "statement_ns": 336978, + "success": true + }, + { + "mutex_wait_ns": 317442, + "serialization_ns": 30147, + "serialized_bytes": 612, + "statement_ns": 357917, + "success": true + }, + { + "mutex_wait_ns": 288618, + "serialization_ns": 64781, + "serialized_bytes": 1300, + "statement_ns": 331859, + "success": true + }, + { + "mutex_wait_ns": 293127, + "serialization_ns": 46237, + "serialized_bytes": 1038, + "statement_ns": 372835, + "success": true + }, + { + "mutex_wait_ns": 113372, + "serialization_ns": 55743, + "serialized_bytes": 610, + "statement_ns": 424121, + "success": true + }, + { + "mutex_wait_ns": 356525, + "serialization_ns": 51226, + "serialized_bytes": 1077, + "statement_ns": 336377, + "success": true + }, + { + "mutex_wait_ns": 316971, + "serialization_ns": 30317, + "serialized_bytes": 610, + "statement_ns": 330797, + "success": true + }, + { + "mutex_wait_ns": 288027, + "serialization_ns": 51727, + "serialized_bytes": 1085, + "statement_ns": 342188, + "success": true + }, + { + "mutex_wait_ns": 303346, + "serialization_ns": 46166, + "serialized_bytes": 1034, + "statement_ns": 325747, + "success": true + }, + { + "mutex_wait_ns": 254715, + "serialization_ns": 60453, + "serialized_bytes": 1300, + "statement_ns": 468123, + "success": true + }, + { + "mutex_wait_ns": 410115, + "serialization_ns": 47979, + "serialized_bytes": 1073, + "statement_ns": 350073, + "success": true + }, + { + "mutex_wait_ns": 102241, + "serialization_ns": 29996, + "serialized_bytes": 612, + "statement_ns": 357587, + "success": true + }, + { + "mutex_wait_ns": 312192, + "serialization_ns": 49102, + "serialized_bytes": 1081, + "statement_ns": 375981, + "success": true + }, + { + "mutex_wait_ns": 363628, + "serialization_ns": 29976, + "serialized_bytes": 612, + "statement_ns": 326148, + "success": true + }, + { + "mutex_wait_ns": 261888, + "serialization_ns": 60563, + "serialized_bytes": 1296, + "statement_ns": 348921, + "success": true + }, + { + "mutex_wait_ns": 307182, + "serialization_ns": 48942, + "serialized_bytes": 1038, + "statement_ns": 356736, + "success": true + }, + { + "mutex_wait_ns": 131215, + "serialization_ns": 42940, + "serialized_bytes": 612, + "statement_ns": 439901, + "success": true + }, + { + "mutex_wait_ns": 373045, + "serialization_ns": 51066, + "serialized_bytes": 1077, + "statement_ns": 360914, + "success": true + }, + { + "mutex_wait_ns": 346737, + "serialization_ns": 31880, + "serialized_bytes": 612, + "statement_ns": 406217, + "success": true + }, + { + "mutex_wait_ns": 365892, + "serialization_ns": 51286, + "serialized_bytes": 1085, + "statement_ns": 399024, + "success": true + }, + { + "mutex_wait_ns": 358288, + "serialization_ns": 47859, + "serialized_bytes": 1038, + "statement_ns": 381332, + "success": true + }, + { + "mutex_wait_ns": 311221, + "serialization_ns": 64911, + "serialized_bytes": 1300, + "statement_ns": 389125, + "success": true + }, + { + "mutex_wait_ns": 321800, + "serialization_ns": 50925, + "serialized_bytes": 1077, + "statement_ns": 360312, + "success": true + }, + { + "mutex_wait_ns": 79529, + "serialization_ns": 32019, + "serialized_bytes": 610, + "statement_ns": 398393, + "success": true + }, + { + "mutex_wait_ns": 348760, + "serialization_ns": 52158, + "serialized_bytes": 1085, + "statement_ns": 369199, + "success": true + }, + { + "mutex_wait_ns": 353038, + "serialization_ns": 32140, + "serialized_bytes": 610, + "statement_ns": 455560, + "success": true + }, + { + "mutex_wait_ns": 391380, + "serialization_ns": 60633, + "serialized_bytes": 1300, + "statement_ns": 343821, + "success": true + }, + { + "mutex_wait_ns": 301061, + "serialization_ns": 44012, + "serialized_bytes": 1034, + "statement_ns": 374629, + "success": true + }, + { + "mutex_wait_ns": 90909, + "serialization_ns": 45676, + "serialized_bytes": 612, + "statement_ns": 423780, + "success": true + }, + { + "mutex_wait_ns": 361495, + "serialization_ns": 48039, + "serialized_bytes": 1073, + "statement_ns": 404494, + "success": true + }, + { + "mutex_wait_ns": 388214, + "serialization_ns": 32641, + "serialized_bytes": 612, + "statement_ns": 343130, + "success": true + }, + { + "mutex_wait_ns": 296854, + "serialization_ns": 48831, + "serialized_bytes": 1081, + "statement_ns": 350584, + "success": true + }, + { + "mutex_wait_ns": 307123, + "serialization_ns": 44513, + "serialized_bytes": 1038, + "statement_ns": 380910, + "success": true + }, + { + "mutex_wait_ns": 319786, + "serialization_ns": 57567, + "serialized_bytes": 1296, + "statement_ns": 413251, + "success": true + }, + { + "mutex_wait_ns": 334624, + "serialization_ns": 69199, + "serialized_bytes": 1077, + "statement_ns": 349892, + "success": true + }, + { + "mutex_wait_ns": 128730, + "serialization_ns": 29274, + "serialized_bytes": 612, + "statement_ns": 395909, + "success": true + }, + { + "mutex_wait_ns": 350464, + "serialization_ns": 49171, + "serialized_bytes": 1085, + "statement_ns": 370631, + "success": true + }, + { + "mutex_wait_ns": 352377, + "serialization_ns": 28784, + "serialized_bytes": 612, + "statement_ns": 386301, + "success": true + }, + { + "mutex_wait_ns": 326569, + "serialization_ns": 56956, + "serialized_bytes": 1300, + "statement_ns": 331879, + "success": true + }, + { + "mutex_wait_ns": 296583, + "serialization_ns": 44032, + "serialized_bytes": 1038, + "statement_ns": 365271, + "success": true + }, + { + "mutex_wait_ns": 116667, + "serialization_ns": 53580, + "serialized_bytes": 610, + "statement_ns": 420815, + "success": true + }, + { + "mutex_wait_ns": 326128, + "serialization_ns": 78426, + "serialized_bytes": 1077, + "statement_ns": 328934, + "success": true + }, + { + "mutex_wait_ns": 308796, + "serialization_ns": 30116, + "serialized_bytes": 610, + "statement_ns": 329775, + "success": true + }, + { + "mutex_wait_ns": 286815, + "serialization_ns": 51326, + "serialized_bytes": 1085, + "statement_ns": 340525, + "success": true + }, + { + "mutex_wait_ns": 303676, + "serialization_ns": 43992, + "serialized_bytes": 1034, + "statement_ns": 329294, + "success": true + }, + { + "mutex_wait_ns": 258292, + "serialization_ns": 60222, + "serialized_bytes": 1300, + "statement_ns": 434781, + "success": true + }, + { + "mutex_wait_ns": 379799, + "serialization_ns": 45986, + "serialized_bytes": 1073, + "statement_ns": 347147, + "success": true + }, + { + "mutex_wait_ns": 107881, + "serialization_ns": 30838, + "serialized_bytes": 610, + "statement_ns": 349692, + "success": true + }, + { + "mutex_wait_ns": 306201, + "serialization_ns": 46737, + "serialized_bytes": 1081, + "statement_ns": 379097, + "success": true + }, + { + "mutex_wait_ns": 365081, + "serialization_ns": 27581, + "serialized_bytes": 610, + "statement_ns": 324716, + "success": true + }, + { + "mutex_wait_ns": 264072, + "serialization_ns": 56656, + "serialized_bytes": 1296, + "statement_ns": 333412, + "success": true + }, + { + "mutex_wait_ns": 290492, + "serialization_ns": 43952, + "serialized_bytes": 1034, + "statement_ns": 405867, + "success": true + }, + { + "mutex_wait_ns": 160399, + "serialization_ns": 29515, + "serialized_bytes": 612, + "statement_ns": 376111, + "success": true + }, + { + "mutex_wait_ns": 312824, + "serialization_ns": 47779, + "serialized_bytes": 1073, + "statement_ns": 374358, + "success": true + }, + { + "mutex_wait_ns": 361495, + "serialization_ns": 30136, + "serialized_bytes": 612, + "statement_ns": 338761, + "success": true + }, + { + "mutex_wait_ns": 299970, + "serialization_ns": 48480, + "serialized_bytes": 1081, + "statement_ns": 376291, + "success": true + }, + { + "mutex_wait_ns": 333342, + "serialization_ns": 44142, + "serialized_bytes": 1038, + "statement_ns": 433107, + "success": true + }, + { + "mutex_wait_ns": 335326, + "serialization_ns": 87513, + "serialized_bytes": 1296, + "statement_ns": 405696, + "success": true + }, + { + "mutex_wait_ns": 341757, + "serialization_ns": 47939, + "serialized_bytes": 1077, + "statement_ns": 394106, + "success": true + }, + { + "mutex_wait_ns": 126275, + "serialization_ns": 32131, + "serialized_bytes": 612, + "statement_ns": 396549, + "success": true + }, + { + "mutex_wait_ns": 347267, + "serialization_ns": 51777, + "serialized_bytes": 1085, + "statement_ns": 341667, + "success": true + }, + { + "mutex_wait_ns": 320698, + "serialization_ns": 31970, + "serialized_bytes": 612, + "statement_ns": 399976, + "success": true + }, + { + "mutex_wait_ns": 296093, + "serialization_ns": 94155, + "serialized_bytes": 1300, + "statement_ns": 435271, + "success": true + }, + { + "mutex_wait_ns": 392642, + "serialization_ns": 43952, + "serialized_bytes": 1038, + "statement_ns": 412400, + "success": true + }, + { + "mutex_wait_ns": 147786, + "serialization_ns": 41407, + "serialized_bytes": 612, + "statement_ns": 401549, + "success": true + }, + { + "mutex_wait_ns": 338802, + "serialization_ns": 47979, + "serialized_bytes": 1077, + "statement_ns": 381912, + "success": true + }, + { + "mutex_wait_ns": 368607, + "serialization_ns": 32330, + "serialized_bytes": 612, + "statement_ns": 344814, + "success": true + }, + { + "mutex_wait_ns": 307063, + "serialization_ns": 48630, + "serialized_bytes": 1085, + "statement_ns": 384578, + "success": true + }, + { + "mutex_wait_ns": 324746, + "serialization_ns": 58359, + "serialized_bytes": 1038, + "statement_ns": 400286, + "success": true + }, + { + "mutex_wait_ns": 337439, + "serialization_ns": 60063, + "serialized_bytes": 1300, + "statement_ns": 412169, + "success": true + }, + { + "mutex_wait_ns": 355383, + "serialization_ns": 48250, + "serialized_bytes": 1077, + "statement_ns": 347718, + "success": true + }, + { + "mutex_wait_ns": 541, + "serialization_ns": 68728, + "serialized_bytes": 610, + "statement_ns": 414673, + "success": true + }, + { + "mutex_wait_ns": 375791, + "serialization_ns": 53981, + "serialized_bytes": 1085, + "statement_ns": 416958, + "success": true + }, + { + "mutex_wait_ns": 397752, + "serialization_ns": 29996, + "serialized_bytes": 610, + "statement_ns": 386080, + "success": true + }, + { + "mutex_wait_ns": 323163, + "serialization_ns": 59891, + "serialized_bytes": 1300, + "statement_ns": 352327, + "success": true + }, + { + "mutex_wait_ns": 316480, + "serialization_ns": 43612, + "serialized_bytes": 1034, + "statement_ns": 376352, + "success": true + }, + { + "mutex_wait_ns": 143127, + "serialization_ns": 49031, + "serialized_bytes": 612, + "statement_ns": 479615, + "success": true + }, + { + "mutex_wait_ns": 421255, + "serialization_ns": 47569, + "serialized_bytes": 1073, + "statement_ns": 357517, + "success": true + }, + { + "mutex_wait_ns": 337599, + "serialization_ns": 30067, + "serialized_bytes": 612, + "statement_ns": 378546, + "success": true + }, + { + "mutex_wait_ns": 337559, + "serialization_ns": 51015, + "serialized_bytes": 1081, + "statement_ns": 335726, + "success": true + }, + { + "mutex_wait_ns": 306942, + "serialization_ns": 44253, + "serialized_bytes": 1038, + "statement_ns": 373807, + "success": true + }, + { + "mutex_wait_ns": 300871, + "serialization_ns": 64009, + "serialized_bytes": 1296, + "statement_ns": 403723, + "success": true + }, + { + "mutex_wait_ns": 347689, + "serialization_ns": 48130, + "serialized_bytes": 1077, + "statement_ns": 363397, + "success": true + }, + { + "mutex_wait_ns": 118832, + "serialization_ns": 29495, + "serialized_bytes": 610, + "statement_ns": 375139, + "success": true + }, + { + "mutex_wait_ns": 333883, + "serialization_ns": 51365, + "serialized_bytes": 1085, + "statement_ns": 328513, + "success": true + }, + { + "mutex_wait_ns": 316310, + "serialization_ns": 29445, + "serialized_bytes": 610, + "statement_ns": 325918, + "success": true + }, + { + "mutex_wait_ns": 256048, + "serialization_ns": 60081, + "serialized_bytes": 1300, + "statement_ns": 391701, + "success": true + }, + { + "mutex_wait_ns": 357317, + "serialization_ns": 43311, + "serialized_bytes": 1034, + "statement_ns": 364509, + "success": true + }, + { + "mutex_wait_ns": 129562, + "serialization_ns": 47348, + "serialized_bytes": 612, + "statement_ns": 406999, + "success": true + }, + { + "mutex_wait_ns": 351706, + "serialization_ns": 46095, + "serialized_bytes": 1073, + "statement_ns": 337139, + "success": true + }, + { + "mutex_wait_ns": 325937, + "serialization_ns": 28283, + "serialized_bytes": 612, + "statement_ns": 320538, + "success": true + }, + { + "mutex_wait_ns": 274793, + "serialization_ns": 48099, + "serialized_bytes": 1081, + "statement_ns": 382544, + "success": true + }, + { + "mutex_wait_ns": 340264, + "serialization_ns": 50434, + "serialized_bytes": 1038, + "statement_ns": 326068, + "success": true + }, + { + "mutex_wait_ns": 263351, + "serialization_ns": 59732, + "serialized_bytes": 1296, + "statement_ns": 382884, + "success": true + }, + { + "mutex_wait_ns": 316420, + "serialization_ns": 50675, + "serialized_bytes": 1077, + "statement_ns": 387292, + "success": true + }, + { + "mutex_wait_ns": 96410, + "serialization_ns": 29986, + "serialized_bytes": 612, + "statement_ns": 348930, + "success": true + }, + { + "mutex_wait_ns": 301052, + "serialization_ns": 51375, + "serialized_bytes": 1085, + "statement_ns": 347799, + "success": true + }, + { + "mutex_wait_ns": 333703, + "serialization_ns": 30507, + "serialized_bytes": 612, + "statement_ns": 349612, + "success": true + }, + { + "mutex_wait_ns": 285473, + "serialization_ns": 60072, + "serialized_bytes": 1300, + "statement_ns": 333762, + "success": true + }, + { + "mutex_wait_ns": 290662, + "serialization_ns": 44233, + "serialized_bytes": 1038, + "statement_ns": 442676, + "success": true + }, + { + "mutex_wait_ns": 182791, + "serialization_ns": 73377, + "serialized_bytes": 612, + "statement_ns": 420955, + "success": true + }, + { + "mutex_wait_ns": 358699, + "serialization_ns": 46216, + "serialized_bytes": 1077, + "statement_ns": 377103, + "success": true + }, + { + "mutex_wait_ns": 357026, + "serialization_ns": 31870, + "serialized_bytes": 612, + "statement_ns": 345785, + "success": true + }, + { + "mutex_wait_ns": 298968, + "serialization_ns": 48991, + "serialized_bytes": 1085, + "statement_ns": 382072, + "success": true + }, + { + "mutex_wait_ns": 339693, + "serialization_ns": 43952, + "serialized_bytes": 1038, + "statement_ns": 369349, + "success": true + }, + { + "mutex_wait_ns": 305180, + "serialization_ns": 60061, + "serialized_bytes": 1300, + "statement_ns": 395698, + "success": true + }, + { + "mutex_wait_ns": 333442, + "serialization_ns": 52147, + "serialized_bytes": 1077, + "statement_ns": 370120, + "success": true + }, + { + "mutex_wait_ns": 118711, + "serialization_ns": 33162, + "serialized_bytes": 610, + "statement_ns": 410846, + "success": true + }, + { + "mutex_wait_ns": 335155, + "serialization_ns": 79248, + "serialized_bytes": 1085, + "statement_ns": 375580, + "success": true + }, + { + "mutex_wait_ns": 356194, + "serialization_ns": 30026, + "serialized_bytes": 610, + "statement_ns": 378626, + "success": true + }, + { + "mutex_wait_ns": 317542, + "serialization_ns": 57117, + "serialized_bytes": 1300, + "statement_ns": 334284, + "success": true + }, + { + "mutex_wait_ns": 298326, + "serialization_ns": 43872, + "serialized_bytes": 1034, + "statement_ns": 405045, + "success": true + }, + { + "mutex_wait_ns": 183041, + "serialization_ns": 27822, + "serialized_bytes": 610, + "statement_ns": 437346, + "success": true + }, + { + "mutex_wait_ns": 374669, + "serialization_ns": 47699, + "serialized_bytes": 1073, + "statement_ns": 337129, + "success": true + }, + { + "mutex_wait_ns": 318594, + "serialization_ns": 29956, + "serialized_bytes": 610, + "statement_ns": 340475, + "success": true + }, + { + "mutex_wait_ns": 301052, + "serialization_ns": 48300, + "serialized_bytes": 1081, + "statement_ns": 491486, + "success": true + }, + { + "mutex_wait_ns": 455539, + "serialization_ns": 43852, + "serialized_bytes": 1034, + "statement_ns": 325307, + "success": true + }, + { + "mutex_wait_ns": 258081, + "serialization_ns": 57036, + "serialized_bytes": 1296, + "statement_ns": 426856, + "success": true + }, + { + "mutex_wait_ns": 365242, + "serialization_ns": 46055, + "serialized_bytes": 1073, + "statement_ns": 336177, + "success": true + }, + { + "mutex_wait_ns": 92243, + "serialization_ns": 30536, + "serialized_bytes": 612, + "statement_ns": 382453, + "success": true + }, + { + "mutex_wait_ns": 339453, + "serialization_ns": 46417, + "serialized_bytes": 1081, + "statement_ns": 326780, + "success": true + }, + { + "mutex_wait_ns": 308055, + "serialization_ns": 29074, + "serialized_bytes": 612, + "statement_ns": 322050, + "success": true + }, + { + "mutex_wait_ns": 266707, + "serialization_ns": 56385, + "serialized_bytes": 1296, + "statement_ns": 412359, + "success": true + }, + { + "mutex_wait_ns": 375911, + "serialization_ns": 45555, + "serialized_bytes": 1038, + "statement_ns": 350744, + "success": true + }, + { + "mutex_wait_ns": 131875, + "serialization_ns": 41157, + "serialized_bytes": 612, + "statement_ns": 380220, + "success": true + }, + { + "mutex_wait_ns": 316811, + "serialization_ns": 47769, + "serialized_bytes": 1077, + "statement_ns": 371653, + "success": true + }, + { + "mutex_wait_ns": 359139, + "serialization_ns": 27061, + "serialized_bytes": 612, + "statement_ns": 336949, + "success": true + }, + { + "mutex_wait_ns": 304017, + "serialization_ns": 51356, + "serialized_bytes": 1085, + "statement_ns": 366373, + "success": true + }, + { + "mutex_wait_ns": 327972, + "serialization_ns": 43681, + "serialized_bytes": 1038, + "statement_ns": 332661, + "success": true + }, + { + "mutex_wait_ns": 266107, + "serialization_ns": 60032, + "serialized_bytes": 1300, + "statement_ns": 420243, + "success": true + }, + { + "mutex_wait_ns": 357226, + "serialization_ns": 47869, + "serialized_bytes": 1077, + "statement_ns": 400447, + "success": true + }, + { + "mutex_wait_ns": 120375, + "serialization_ns": 33081, + "serialized_bytes": 612, + "statement_ns": 393464, + "success": true + }, + { + "mutex_wait_ns": 346817, + "serialization_ns": 51576, + "serialized_bytes": 1085, + "statement_ns": 409824, + "success": true + }, + { + "mutex_wait_ns": 393574, + "serialization_ns": 32540, + "serialized_bytes": 612, + "statement_ns": 335677, + "success": true + }, + { + "mutex_wait_ns": 271726, + "serialization_ns": 59872, + "serialized_bytes": 1300, + "statement_ns": 358860, + "success": true + }, + { + "mutex_wait_ns": 317482, + "serialization_ns": 43200, + "serialized_bytes": 1038, + "statement_ns": 371503, + "success": true + }, + { + "mutex_wait_ns": 97892, + "serialization_ns": 44854, + "serialized_bytes": 612, + "statement_ns": 380349, + "success": true + }, + { + "mutex_wait_ns": 319816, + "serialization_ns": 45385, + "serialized_bytes": 1077, + "statement_ns": 331939, + "success": true + }, + { + "mutex_wait_ns": 312243, + "serialization_ns": 29886, + "serialized_bytes": 612, + "statement_ns": 356675, + "success": true + }, + { + "mutex_wait_ns": 320718, + "serialization_ns": 46477, + "serialized_bytes": 1085, + "statement_ns": 370180, + "success": true + }, + { + "mutex_wait_ns": 336167, + "serialization_ns": 43120, + "serialized_bytes": 1038, + "statement_ns": 540448, + "success": true + }, + { + "mutex_wait_ns": 482469, + "serialization_ns": 54161, + "serialized_bytes": 1300, + "statement_ns": 515091, + "success": true + }, + { + "mutex_wait_ns": 459387, + "serialization_ns": 46086, + "serialized_bytes": 1077, + "statement_ns": 395237, + "success": true + }, + { + "mutex_wait_ns": 124833, + "serialization_ns": 34545, + "serialized_bytes": 612, + "statement_ns": 395347, + "success": true + }, + { + "mutex_wait_ns": 347147, + "serialization_ns": 49142, + "serialized_bytes": 1085, + "statement_ns": 325037, + "success": true + }, + { + "mutex_wait_ns": 306481, + "serialization_ns": 29535, + "serialized_bytes": 612, + "statement_ns": 371153, + "success": true + }, + { + "mutex_wait_ns": 278810, + "serialization_ns": 82674, + "serialized_bytes": 1300, + "statement_ns": 343601, + "success": true + }, + { + "mutex_wait_ns": 298988, + "serialization_ns": 45605, + "serialized_bytes": 1038, + "statement_ns": 381472, + "success": true + }, + { + "mutex_wait_ns": 261, + "serialization_ns": 51085, + "serialized_bytes": 1077, + "statement_ns": 559884, + "success": true + }, + { + "mutex_wait_ns": 499291, + "serialization_ns": 29575, + "serialized_bytes": 612, + "statement_ns": 486918, + "success": true + }, + { + "mutex_wait_ns": 439740, + "serialization_ns": 51507, + "serialized_bytes": 1085, + "statement_ns": 378235, + "success": true + }, + { + "mutex_wait_ns": 359370, + "serialization_ns": 30437, + "serialized_bytes": 612, + "statement_ns": 475978, + "success": true + }, + { + "mutex_wait_ns": 407249, + "serialization_ns": 60363, + "serialized_bytes": 1300, + "statement_ns": 441413, + "success": true + }, + { + "mutex_wait_ns": 391330, + "serialization_ns": 49232, + "serialized_bytes": 1038, + "statement_ns": 367986, + "success": true + }, + { + "mutex_wait_ns": 250, + "serialization_ns": 51737, + "serialized_bytes": 1077, + "statement_ns": 475457, + "success": true + }, + { + "mutex_wait_ns": 151, + "serialization_ns": 56194, + "serialized_bytes": 1085, + "statement_ns": 419482, + "success": true + }, + { + "mutex_wait_ns": 240, + "serialization_ns": 87093, + "serialized_bytes": 1300, + "statement_ns": 550407, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 3153561, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=1", + "COMPILER=gcc-11.4.0", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_PTHREADS", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "HTTP", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 84755199, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 32323107, + 32357398, + 33106696, + 32662701, + 33414472, + 32836131, + 33504207, + 33108783, + 33811614, + 33178770, + 43560549, + 75237710, + 76164568, + 77883978, + 78594831, + 76660493, + 78801897, + 79862733, + 81073191, + 80523975, + 80709335, + 81454451, + 80925645, + 81809838, + 81783388, + 81968540, + 81127922, + 82191005, + 80985918, + 80911491, + 82592307, + 81978812 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 23695834, + 37973934, + 188732, + 190916 + ], + "failures": 0, + "in_window_samples": 2, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 23695834, + "end_ns": 34094778, + "in_window": true, + "scheduled_ns": null, + "start_ns": 10398944, + "success": true + }, + { + "elapsed_ns": 37973934, + "end_ns": 82146668, + "in_window": true, + "scheduled_ns": null, + "start_ns": 44172734, + "success": true + }, + { + "elapsed_ns": 188732, + "end_ns": 92412183, + "in_window": false, + "scheduled_ns": null, + "start_ns": 92223451, + "success": true + }, + { + "elapsed_ns": 190916, + "end_ns": 102676858, + "in_window": false, + "scheduled_ns": null, + "start_ns": 102485942, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 18069815, + 9170095, + 39531771, + 4531464, + 1050798, + 81721, + 345230 + ], + "failures": 0, + "in_window_samples": 4, + "missed_periods": 4, + "samples": [ + { + "elapsed_ns": 18069815, + "end_ns": 30570070, + "in_window": true, + "scheduled_ns": 12500255, + "start_ns": 30570070, + "success": true + }, + { + "elapsed_ns": 9170095, + "end_ns": 41670350, + "in_window": true, + "scheduled_ns": 32500255, + "start_ns": 41670350, + "success": true + }, + { + "elapsed_ns": 39531771, + "end_ns": 82032026, + "in_window": true, + "scheduled_ns": 42500255, + "start_ns": 82032026, + "success": true + }, + { + "elapsed_ns": 4531464, + "end_ns": 87031719, + "in_window": true, + "scheduled_ns": 82500255, + "start_ns": 87031719, + "success": true + }, + { + "elapsed_ns": 1050798, + "end_ns": 93551053, + "in_window": false, + "scheduled_ns": 92500255, + "start_ns": 93551053, + "success": true + }, + { + "elapsed_ns": 81721, + "end_ns": 102581976, + "in_window": false, + "scheduled_ns": 102500255, + "start_ns": 102581976, + "success": true + }, + { + "elapsed_ns": 345230, + "end_ns": 112845485, + "in_window": false, + "scheduled_ns": 112500255, + "start_ns": 112845485, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 87273776, + "window_start_ns": 2518577 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 1, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 471, + "serialization_ns": 28052, + "serialized_bytes": 610, + "statement_ns": 447285, + "success": true + }, + { + "mutex_wait_ns": 382684, + "serialization_ns": 27291, + "serialized_bytes": 612, + "statement_ns": 402350, + "success": true + }, + { + "mutex_wait_ns": 384277, + "serialization_ns": 27190, + "serialized_bytes": 610, + "statement_ns": 378967, + "success": true + }, + { + "mutex_wait_ns": 333682, + "serialization_ns": 55954, + "serialized_bytes": 612, + "statement_ns": 337660, + "success": true + }, + { + "mutex_wait_ns": 292254, + "serialization_ns": 44293, + "serialized_bytes": 1034, + "statement_ns": 346918, + "success": true + }, + { + "mutex_wait_ns": 307313, + "serialization_ns": 43612, + "serialized_bytes": 1038, + "statement_ns": 358077, + "success": true + }, + { + "mutex_wait_ns": 285372, + "serialization_ns": 45816, + "serialized_bytes": 1073, + "statement_ns": 332000, + "success": true + }, + { + "mutex_wait_ns": 269262, + "serialization_ns": 45525, + "serialized_bytes": 1077, + "statement_ns": 383625, + "success": true + }, + { + "mutex_wait_ns": 337419, + "serialization_ns": 46237, + "serialized_bytes": 1081, + "statement_ns": 347338, + "success": true + }, + { + "mutex_wait_ns": 303186, + "serialization_ns": 46266, + "serialized_bytes": 1085, + "statement_ns": 378145, + "success": true + }, + { + "mutex_wait_ns": 313224, + "serialization_ns": 53560, + "serialized_bytes": 1296, + "statement_ns": 388805, + "success": true + }, + { + "mutex_wait_ns": 291984, + "serialization_ns": 86582, + "serialized_bytes": 1300, + "statement_ns": 563211, + "success": true + }, + { + "mutex_wait_ns": 353098, + "serialization_ns": 33683, + "serialized_bytes": 612, + "statement_ns": 465759, + "success": true + }, + { + "mutex_wait_ns": 232393, + "serialization_ns": 31639, + "serialized_bytes": 612, + "statement_ns": 431906, + "success": true + }, + { + "mutex_wait_ns": 415755, + "serialization_ns": 27331, + "serialized_bytes": 612, + "statement_ns": 379438, + "success": true + }, + { + "mutex_wait_ns": 366414, + "serialization_ns": 27852, + "serialized_bytes": 612, + "statement_ns": 336237, + "success": true + }, + { + "mutex_wait_ns": 298707, + "serialization_ns": 43601, + "serialized_bytes": 1038, + "statement_ns": 380410, + "success": true + }, + { + "mutex_wait_ns": 336968, + "serialization_ns": 44192, + "serialized_bytes": 1038, + "statement_ns": 397793, + "success": true + }, + { + "mutex_wait_ns": 306411, + "serialization_ns": 49663, + "serialized_bytes": 1077, + "statement_ns": 331058, + "success": true + }, + { + "mutex_wait_ns": 267368, + "serialization_ns": 46427, + "serialized_bytes": 1077, + "statement_ns": 352498, + "success": true + }, + { + "mutex_wait_ns": 313635, + "serialization_ns": 47258, + "serialized_bytes": 1085, + "statement_ns": 332901, + "success": true + }, + { + "mutex_wait_ns": 293538, + "serialization_ns": 47308, + "serialized_bytes": 1085, + "statement_ns": 382073, + "success": true + }, + { + "mutex_wait_ns": 317422, + "serialization_ns": 55293, + "serialized_bytes": 1300, + "statement_ns": 382724, + "success": true + }, + { + "mutex_wait_ns": 321519, + "serialization_ns": 56926, + "serialized_bytes": 1300, + "statement_ns": 371003, + "success": true + }, + { + "mutex_wait_ns": 186357, + "serialization_ns": 28203, + "serialized_bytes": 612, + "statement_ns": 360302, + "success": true + }, + { + "mutex_wait_ns": 128068, + "serialization_ns": 67476, + "serialized_bytes": 610, + "statement_ns": 426035, + "success": true + }, + { + "mutex_wait_ns": 376763, + "serialization_ns": 60192, + "serialized_bytes": 612, + "statement_ns": 318414, + "success": true + }, + { + "mutex_wait_ns": 298056, + "serialization_ns": 30417, + "serialized_bytes": 610, + "statement_ns": 413631, + "success": true + }, + { + "mutex_wait_ns": 373296, + "serialization_ns": 47980, + "serialized_bytes": 1038, + "statement_ns": 341197, + "success": true + }, + { + "mutex_wait_ns": 304017, + "serialization_ns": 44222, + "serialized_bytes": 1034, + "statement_ns": 365582, + "success": true + }, + { + "mutex_wait_ns": 301592, + "serialization_ns": 48000, + "serialized_bytes": 1077, + "statement_ns": 386932, + "success": true + }, + { + "mutex_wait_ns": 329584, + "serialization_ns": 46887, + "serialized_bytes": 1073, + "statement_ns": 375491, + "success": true + }, + { + "mutex_wait_ns": 334274, + "serialization_ns": 48710, + "serialized_bytes": 1085, + "statement_ns": 374849, + "success": true + }, + { + "mutex_wait_ns": 332100, + "serialization_ns": 48661, + "serialized_bytes": 1081, + "statement_ns": 354441, + "success": true + }, + { + "mutex_wait_ns": 286635, + "serialization_ns": 60242, + "serialized_bytes": 1300, + "statement_ns": 394936, + "success": true + }, + { + "mutex_wait_ns": 323753, + "serialization_ns": 60884, + "serialized_bytes": 1296, + "statement_ns": 382474, + "success": true + }, + { + "mutex_wait_ns": 131245, + "serialization_ns": 45415, + "serialized_bytes": 610, + "statement_ns": 377684, + "success": true + }, + { + "mutex_wait_ns": 136685, + "serialization_ns": 68608, + "serialized_bytes": 612, + "statement_ns": 433990, + "success": true + }, + { + "mutex_wait_ns": 423160, + "serialization_ns": 28232, + "serialized_bytes": 610, + "statement_ns": 324996, + "success": true + }, + { + "mutex_wait_ns": 311522, + "serialization_ns": 30036, + "serialized_bytes": 612, + "statement_ns": 353238, + "success": true + }, + { + "mutex_wait_ns": 309798, + "serialization_ns": 43962, + "serialized_bytes": 1034, + "statement_ns": 388865, + "success": true + }, + { + "mutex_wait_ns": 348430, + "serialization_ns": 45825, + "serialized_bytes": 1038, + "statement_ns": 354601, + "success": true + }, + { + "mutex_wait_ns": 295191, + "serialization_ns": 47889, + "serialized_bytes": 1073, + "statement_ns": 371903, + "success": true + }, + { + "mutex_wait_ns": 307574, + "serialization_ns": 47979, + "serialized_bytes": 1077, + "statement_ns": 443497, + "success": true + }, + { + "mutex_wait_ns": 368497, + "serialization_ns": 78136, + "serialized_bytes": 1081, + "statement_ns": 361063, + "success": true + }, + { + "mutex_wait_ns": 311661, + "serialization_ns": 51717, + "serialized_bytes": 1085, + "statement_ns": 465779, + "success": true + }, + { + "mutex_wait_ns": 402421, + "serialization_ns": 59972, + "serialized_bytes": 1296, + "statement_ns": 371673, + "success": true + }, + { + "mutex_wait_ns": 303166, + "serialization_ns": 64731, + "serialized_bytes": 1300, + "statement_ns": 391420, + "success": true + }, + { + "mutex_wait_ns": 180015, + "serialization_ns": 29515, + "serialized_bytes": 612, + "statement_ns": 380690, + "success": true + }, + { + "mutex_wait_ns": 146643, + "serialization_ns": 70121, + "serialized_bytes": 610, + "statement_ns": 377073, + "success": true + }, + { + "mutex_wait_ns": 356986, + "serialization_ns": 30367, + "serialized_bytes": 612, + "statement_ns": 351235, + "success": true + }, + { + "mutex_wait_ns": 335736, + "serialization_ns": 29966, + "serialized_bytes": 610, + "statement_ns": 461420, + "success": true + }, + { + "mutex_wait_ns": 420824, + "serialization_ns": 46046, + "serialized_bytes": 1038, + "statement_ns": 409774, + "success": true + }, + { + "mutex_wait_ns": 368868, + "serialization_ns": 44604, + "serialized_bytes": 1034, + "statement_ns": 357907, + "success": true + }, + { + "mutex_wait_ns": 295260, + "serialization_ns": 50805, + "serialized_bytes": 1077, + "statement_ns": 342169, + "success": true + }, + { + "mutex_wait_ns": 288117, + "serialization_ns": 47729, + "serialized_bytes": 1073, + "statement_ns": 379187, + "success": true + }, + { + "mutex_wait_ns": 336398, + "serialization_ns": 51365, + "serialized_bytes": 1085, + "statement_ns": 332981, + "success": true + }, + { + "mutex_wait_ns": 293938, + "serialization_ns": 48591, + "serialized_bytes": 1081, + "statement_ns": 419884, + "success": true + }, + { + "mutex_wait_ns": 349301, + "serialization_ns": 60343, + "serialized_bytes": 1300, + "statement_ns": 444489, + "success": true + }, + { + "mutex_wait_ns": 345485, + "serialization_ns": 63458, + "serialized_bytes": 1296, + "statement_ns": 362035, + "success": true + }, + { + "mutex_wait_ns": 159959, + "serialization_ns": 31598, + "serialized_bytes": 612, + "statement_ns": 405195, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 28583, + "serialized_bytes": 612, + "statement_ns": 344924, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 45856, + "serialized_bytes": 1038, + "statement_ns": 366724, + "success": true + }, + { + "mutex_wait_ns": 166771, + "serialization_ns": 67455, + "serialized_bytes": 610, + "statement_ns": 409334, + "success": true + }, + { + "mutex_wait_ns": 345975, + "serialization_ns": 48029, + "serialized_bytes": 1077, + "statement_ns": 326359, + "success": true + }, + { + "mutex_wait_ns": 310079, + "serialization_ns": 27280, + "serialized_bytes": 610, + "statement_ns": 347057, + "success": true + }, + { + "mutex_wait_ns": 307383, + "serialization_ns": 48460, + "serialized_bytes": 1085, + "statement_ns": 349722, + "success": true + }, + { + "mutex_wait_ns": 314306, + "serialization_ns": 43411, + "serialized_bytes": 1034, + "statement_ns": 347649, + "success": true + }, + { + "mutex_wait_ns": 276987, + "serialization_ns": 60803, + "serialized_bytes": 1300, + "statement_ns": 420885, + "success": true + }, + { + "mutex_wait_ns": 359000, + "serialization_ns": 45505, + "serialized_bytes": 1073, + "statement_ns": 379628, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 46156, + "serialized_bytes": 1081, + "statement_ns": 402009, + "success": true + }, + { + "mutex_wait_ns": 221, + "serialization_ns": 53610, + "serialized_bytes": 1296, + "statement_ns": 384747, + "success": true + }, + { + "mutex_wait_ns": 360, + "serialization_ns": 27171, + "serialized_bytes": 610, + "statement_ns": 396239, + "success": true + }, + { + "mutex_wait_ns": 296122, + "serialization_ns": 26700, + "serialized_bytes": 612, + "statement_ns": 429481, + "success": true + }, + { + "mutex_wait_ns": 420093, + "serialization_ns": 27581, + "serialized_bytes": 610, + "statement_ns": 328373, + "success": true + }, + { + "mutex_wait_ns": 317603, + "serialization_ns": 27341, + "serialized_bytes": 612, + "statement_ns": 323553, + "success": true + }, + { + "mutex_wait_ns": 280312, + "serialization_ns": 43752, + "serialized_bytes": 1034, + "statement_ns": 346537, + "success": true + }, + { + "mutex_wait_ns": 303867, + "serialization_ns": 43912, + "serialized_bytes": 1038, + "statement_ns": 392372, + "success": true + }, + { + "mutex_wait_ns": 329544, + "serialization_ns": 45666, + "serialized_bytes": 1073, + "statement_ns": 343371, + "success": true + }, + { + "mutex_wait_ns": 281475, + "serialization_ns": 45665, + "serialized_bytes": 1077, + "statement_ns": 393093, + "success": true + }, + { + "mutex_wait_ns": 317772, + "serialization_ns": 79018, + "serialized_bytes": 1081, + "statement_ns": 335837, + "success": true + }, + { + "mutex_wait_ns": 291103, + "serialization_ns": 46667, + "serialized_bytes": 1085, + "statement_ns": 424291, + "success": true + }, + { + "mutex_wait_ns": 366994, + "serialization_ns": 53740, + "serialized_bytes": 1296, + "statement_ns": 372855, + "success": true + }, + { + "mutex_wait_ns": 315128, + "serialization_ns": 53951, + "serialized_bytes": 1300, + "statement_ns": 343270, + "success": true + }, + { + "mutex_wait_ns": 110035, + "serialization_ns": 28434, + "serialized_bytes": 612, + "statement_ns": 439069, + "success": true + }, + { + "mutex_wait_ns": 126987, + "serialization_ns": 49102, + "serialized_bytes": 612, + "statement_ns": 390929, + "success": true + }, + { + "mutex_wait_ns": 373527, + "serialization_ns": 27922, + "serialized_bytes": 612, + "statement_ns": 588177, + "success": true + }, + { + "mutex_wait_ns": 578499, + "serialization_ns": 27070, + "serialized_bytes": 612, + "statement_ns": 371864, + "success": true + }, + { + "mutex_wait_ns": 333742, + "serialization_ns": 45936, + "serialized_bytes": 1038, + "statement_ns": 360793, + "success": true + }, + { + "mutex_wait_ns": 324645, + "serialization_ns": 44483, + "serialized_bytes": 1038, + "statement_ns": 422659, + "success": true + }, + { + "mutex_wait_ns": 354421, + "serialization_ns": 48460, + "serialized_bytes": 1077, + "statement_ns": 377565, + "success": true + }, + { + "mutex_wait_ns": 277207, + "serialization_ns": 76703, + "serialized_bytes": 1077, + "statement_ns": 381973, + "success": true + }, + { + "mutex_wait_ns": 309347, + "serialization_ns": 75781, + "serialized_bytes": 1085, + "statement_ns": 353900, + "success": true + }, + { + "mutex_wait_ns": 307253, + "serialization_ns": 49242, + "serialized_bytes": 1085, + "statement_ns": 366584, + "success": true + }, + { + "mutex_wait_ns": 292496, + "serialization_ns": 69549, + "serialized_bytes": 1300, + "statement_ns": 374048, + "success": true + }, + { + "mutex_wait_ns": 309537, + "serialization_ns": 60463, + "serialized_bytes": 1300, + "statement_ns": 349151, + "success": true + }, + { + "mutex_wait_ns": 109995, + "serialization_ns": 34124, + "serialized_bytes": 610, + "statement_ns": 438358, + "success": true + }, + { + "mutex_wait_ns": 401, + "serialization_ns": 30977, + "serialized_bytes": 612, + "statement_ns": 418400, + "success": true + }, + { + "mutex_wait_ns": 413601, + "serialization_ns": 30437, + "serialized_bytes": 610, + "statement_ns": 363108, + "success": true + }, + { + "mutex_wait_ns": 349361, + "serialization_ns": 29816, + "serialized_bytes": 612, + "statement_ns": 330697, + "success": true + }, + { + "mutex_wait_ns": 289821, + "serialization_ns": 48881, + "serialized_bytes": 1034, + "statement_ns": 345744, + "success": true + }, + { + "mutex_wait_ns": 302725, + "serialization_ns": 44192, + "serialized_bytes": 1038, + "statement_ns": 370020, + "success": true + }, + { + "mutex_wait_ns": 308976, + "serialization_ns": 50725, + "serialized_bytes": 1073, + "statement_ns": 413241, + "success": true + }, + { + "mutex_wait_ns": 356865, + "serialization_ns": 46547, + "serialized_bytes": 1077, + "statement_ns": 414804, + "success": true + }, + { + "mutex_wait_ns": 368447, + "serialization_ns": 56886, + "serialized_bytes": 1081, + "statement_ns": 356034, + "success": true + }, + { + "mutex_wait_ns": 317923, + "serialization_ns": 47048, + "serialized_bytes": 1085, + "statement_ns": 338691, + "success": true + }, + { + "mutex_wait_ns": 263351, + "serialization_ns": 64981, + "serialized_bytes": 1296, + "statement_ns": 400417, + "success": true + }, + { + "mutex_wait_ns": 342098, + "serialization_ns": 55253, + "serialized_bytes": 1300, + "statement_ns": 356114, + "success": true + }, + { + "mutex_wait_ns": 68578, + "serialization_ns": 31789, + "serialized_bytes": 612, + "statement_ns": 383716, + "success": true + }, + { + "mutex_wait_ns": 182661, + "serialization_ns": 28132, + "serialized_bytes": 612, + "statement_ns": 425193, + "success": true + }, + { + "mutex_wait_ns": 411367, + "serialization_ns": 32120, + "serialized_bytes": 612, + "statement_ns": 341737, + "success": true + }, + { + "mutex_wait_ns": 330937, + "serialization_ns": 28563, + "serialized_bytes": 612, + "statement_ns": 338782, + "success": true + }, + { + "mutex_wait_ns": 300000, + "serialization_ns": 45735, + "serialized_bytes": 1038, + "statement_ns": 373887, + "success": true + }, + { + "mutex_wait_ns": 335526, + "serialization_ns": 46276, + "serialized_bytes": 1038, + "statement_ns": 363979, + "success": true + }, + { + "mutex_wait_ns": 301462, + "serialization_ns": 46206, + "serialized_bytes": 1077, + "statement_ns": 362747, + "success": true + }, + { + "mutex_wait_ns": 296053, + "serialization_ns": 57567, + "serialized_bytes": 1077, + "statement_ns": 351805, + "success": true + }, + { + "mutex_wait_ns": 314778, + "serialization_ns": 46947, + "serialized_bytes": 1085, + "statement_ns": 343350, + "success": true + }, + { + "mutex_wait_ns": 294580, + "serialization_ns": 51636, + "serialized_bytes": 1085, + "statement_ns": 399304, + "success": true + }, + { + "mutex_wait_ns": 302143, + "serialization_ns": 86862, + "serialized_bytes": 1300, + "statement_ns": 374689, + "success": true + }, + { + "mutex_wait_ns": 304267, + "serialization_ns": 60813, + "serialized_bytes": 1300, + "statement_ns": 388245, + "success": true + }, + { + "mutex_wait_ns": 112159, + "serialization_ns": 60022, + "serialized_bytes": 612, + "statement_ns": 373497, + "success": true + }, + { + "mutex_wait_ns": 195074, + "serialization_ns": 29425, + "serialized_bytes": 612, + "statement_ns": 375150, + "success": true + }, + { + "mutex_wait_ns": 356705, + "serialization_ns": 28904, + "serialized_bytes": 612, + "statement_ns": 356525, + "success": true + }, + { + "mutex_wait_ns": 343540, + "serialization_ns": 29826, + "serialized_bytes": 612, + "statement_ns": 326940, + "success": true + }, + { + "mutex_wait_ns": 288718, + "serialization_ns": 46918, + "serialized_bytes": 1038, + "statement_ns": 362707, + "success": true + }, + { + "mutex_wait_ns": 335606, + "serialization_ns": 46497, + "serialized_bytes": 1038, + "statement_ns": 351876, + "success": true + }, + { + "mutex_wait_ns": 279050, + "serialization_ns": 51206, + "serialized_bytes": 1077, + "statement_ns": 2840358, + "success": true + }, + { + "mutex_wait_ns": 2782159, + "serialization_ns": 49312, + "serialized_bytes": 1077, + "statement_ns": 468364, + "success": true + }, + { + "mutex_wait_ns": 421646, + "serialization_ns": 57508, + "serialized_bytes": 1085, + "statement_ns": 463655, + "success": true + }, + { + "mutex_wait_ns": 409954, + "serialization_ns": 61745, + "serialized_bytes": 1085, + "statement_ns": 383586, + "success": true + }, + { + "mutex_wait_ns": 308766, + "serialization_ns": 64951, + "serialized_bytes": 1300, + "statement_ns": 386040, + "success": true + }, + { + "mutex_wait_ns": 323513, + "serialization_ns": 69900, + "serialized_bytes": 1300, + "statement_ns": 449048, + "success": true + }, + { + "mutex_wait_ns": 248964, + "serialization_ns": 32481, + "serialized_bytes": 610, + "statement_ns": 404364, + "success": true + }, + { + "mutex_wait_ns": 210903, + "serialization_ns": 31519, + "serialized_bytes": 612, + "statement_ns": 456832, + "success": true + }, + { + "mutex_wait_ns": 442585, + "serialization_ns": 32331, + "serialized_bytes": 610, + "statement_ns": 333602, + "success": true + }, + { + "mutex_wait_ns": 320368, + "serialization_ns": 29846, + "serialized_bytes": 612, + "statement_ns": 350734, + "success": true + }, + { + "mutex_wait_ns": 311952, + "serialization_ns": 46026, + "serialized_bytes": 1034, + "statement_ns": 346736, + "success": true + }, + { + "mutex_wait_ns": 300601, + "serialization_ns": 53750, + "serialized_bytes": 1038, + "statement_ns": 341747, + "success": true + }, + { + "mutex_wait_ns": 281776, + "serialization_ns": 50735, + "serialized_bytes": 1073, + "statement_ns": 376121, + "success": true + }, + { + "mutex_wait_ns": 308726, + "serialization_ns": 54792, + "serialized_bytes": 1077, + "statement_ns": 337680, + "success": true + }, + { + "mutex_wait_ns": 295952, + "serialization_ns": 51516, + "serialized_bytes": 1081, + "statement_ns": 392983, + "success": true + }, + { + "mutex_wait_ns": 339082, + "serialization_ns": 56516, + "serialized_bytes": 1085, + "statement_ns": 379578, + "success": true + }, + { + "mutex_wait_ns": 280894, + "serialization_ns": 88314, + "serialized_bytes": 1296, + "statement_ns": 390188, + "success": true + }, + { + "mutex_wait_ns": 317803, + "serialization_ns": 61775, + "serialized_bytes": 1300, + "statement_ns": 364991, + "success": true + }, + { + "mutex_wait_ns": 118881, + "serialization_ns": 30277, + "serialized_bytes": 612, + "statement_ns": 384728, + "success": true + }, + { + "mutex_wait_ns": 208819, + "serialization_ns": 29565, + "serialized_bytes": 612, + "statement_ns": 391310, + "success": true + }, + { + "mutex_wait_ns": 371643, + "serialization_ns": 30036, + "serialized_bytes": 612, + "statement_ns": 378596, + "success": true + }, + { + "mutex_wait_ns": 366343, + "serialization_ns": 29845, + "serialized_bytes": 612, + "statement_ns": 352277, + "success": true + }, + { + "mutex_wait_ns": 317142, + "serialization_ns": 44513, + "serialized_bytes": 1038, + "statement_ns": 360793, + "success": true + }, + { + "mutex_wait_ns": 322652, + "serialization_ns": 44563, + "serialized_bytes": 1038, + "statement_ns": 331358, + "success": true + }, + { + "mutex_wait_ns": 274832, + "serialization_ns": 46407, + "serialized_bytes": 1077, + "statement_ns": 339764, + "success": true + }, + { + "mutex_wait_ns": 279341, + "serialization_ns": 45625, + "serialized_bytes": 1077, + "statement_ns": 346496, + "success": true + }, + { + "mutex_wait_ns": 305029, + "serialization_ns": 49352, + "serialized_bytes": 1085, + "statement_ns": 348089, + "success": true + }, + { + "mutex_wait_ns": 310179, + "serialization_ns": 47258, + "serialized_bytes": 1085, + "statement_ns": 351675, + "success": true + }, + { + "mutex_wait_ns": 284931, + "serialization_ns": 57006, + "serialized_bytes": 1300, + "statement_ns": 378867, + "success": true + }, + { + "mutex_wait_ns": 318634, + "serialization_ns": 57216, + "serialized_bytes": 1300, + "statement_ns": 341076, + "success": true + }, + { + "mutex_wait_ns": 116257, + "serialization_ns": 38432, + "serialized_bytes": 610, + "statement_ns": 371733, + "success": true + }, + { + "mutex_wait_ns": 198049, + "serialization_ns": 28183, + "serialized_bytes": 612, + "statement_ns": 442736, + "success": true + }, + { + "mutex_wait_ns": 430643, + "serialization_ns": 30226, + "serialized_bytes": 610, + "statement_ns": 336578, + "success": true + }, + { + "mutex_wait_ns": 321911, + "serialization_ns": 31819, + "serialized_bytes": 612, + "statement_ns": 374057, + "success": true + }, + { + "mutex_wait_ns": 334294, + "serialization_ns": 46607, + "serialized_bytes": 1034, + "statement_ns": 358578, + "success": true + }, + { + "mutex_wait_ns": 317051, + "serialization_ns": 49022, + "serialized_bytes": 1038, + "statement_ns": 348069, + "success": true + }, + { + "mutex_wait_ns": 286014, + "serialization_ns": 46296, + "serialized_bytes": 1073, + "statement_ns": 357186, + "success": true + }, + { + "mutex_wait_ns": 296894, + "serialization_ns": 50985, + "serialized_bytes": 1077, + "statement_ns": 338912, + "success": true + }, + { + "mutex_wait_ns": 300100, + "serialization_ns": 48711, + "serialized_bytes": 1081, + "statement_ns": 356475, + "success": true + }, + { + "mutex_wait_ns": 303697, + "serialization_ns": 55544, + "serialized_bytes": 1085, + "statement_ns": 384677, + "success": true + }, + { + "mutex_wait_ns": 286655, + "serialization_ns": 61174, + "serialized_bytes": 1296, + "statement_ns": 377494, + "success": true + }, + { + "mutex_wait_ns": 306932, + "serialization_ns": 60864, + "serialized_bytes": 1300, + "statement_ns": 375340, + "success": true + }, + { + "mutex_wait_ns": 90178, + "serialization_ns": 80941, + "serialized_bytes": 612, + "statement_ns": 407260, + "success": true + }, + { + "mutex_wait_ns": 236591, + "serialization_ns": 29455, + "serialized_bytes": 612, + "statement_ns": 392923, + "success": true + }, + { + "mutex_wait_ns": 383455, + "serialization_ns": 30156, + "serialized_bytes": 612, + "statement_ns": 376833, + "success": true + }, + { + "mutex_wait_ns": 327130, + "serialization_ns": 58379, + "serialized_bytes": 612, + "statement_ns": 325608, + "success": true + }, + { + "mutex_wait_ns": 282968, + "serialization_ns": 44493, + "serialized_bytes": 1038, + "statement_ns": 377804, + "success": true + }, + { + "mutex_wait_ns": 342419, + "serialization_ns": 43951, + "serialized_bytes": 1038, + "statement_ns": 337139, + "success": true + }, + { + "mutex_wait_ns": 280203, + "serialization_ns": 46567, + "serialized_bytes": 1077, + "statement_ns": 334033, + "success": true + }, + { + "mutex_wait_ns": 272238, + "serialization_ns": 46166, + "serialized_bytes": 1077, + "statement_ns": 353730, + "success": true + }, + { + "mutex_wait_ns": 316410, + "serialization_ns": 46757, + "serialized_bytes": 1085, + "statement_ns": 336247, + "success": true + }, + { + "mutex_wait_ns": 296584, + "serialization_ns": 48851, + "serialized_bytes": 1085, + "statement_ns": 348610, + "success": true + }, + { + "mutex_wait_ns": 281955, + "serialization_ns": 57297, + "serialized_bytes": 1300, + "statement_ns": 443267, + "success": true + }, + { + "mutex_wait_ns": 381462, + "serialization_ns": 58339, + "serialized_bytes": 1300, + "statement_ns": 370841, + "success": true + }, + { + "mutex_wait_ns": 142385, + "serialization_ns": 66114, + "serialized_bytes": 610, + "statement_ns": 432557, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 29916, + "serialized_bytes": 610, + "statement_ns": 355783, + "success": true + }, + { + "mutex_wait_ns": 161, + "serialization_ns": 46827, + "serialized_bytes": 1034, + "statement_ns": 361228, + "success": true + }, + { + "mutex_wait_ns": 451, + "serialization_ns": 91019, + "serialized_bytes": 1073, + "statement_ns": 417740, + "success": true + }, + { + "mutex_wait_ns": 281806, + "serialization_ns": 45555, + "serialized_bytes": 612, + "statement_ns": 388564, + "success": true + }, + { + "mutex_wait_ns": 307263, + "serialization_ns": 85670, + "serialized_bytes": 1081, + "statement_ns": 378996, + "success": true + }, + { + "mutex_wait_ns": 322982, + "serialization_ns": 69539, + "serialized_bytes": 612, + "statement_ns": 339905, + "success": true + }, + { + "mutex_wait_ns": 220531, + "serialization_ns": 105016, + "serialized_bytes": 1296, + "statement_ns": 385730, + "success": true + }, + { + "mutex_wait_ns": 306171, + "serialization_ns": 79719, + "serialized_bytes": 1038, + "statement_ns": 393183, + "success": true + }, + { + "mutex_wait_ns": 411, + "serialization_ns": 85309, + "serialized_bytes": 1077, + "statement_ns": 465478, + "success": true + }, + { + "mutex_wait_ns": 410, + "serialization_ns": 86642, + "serialized_bytes": 1085, + "statement_ns": 447154, + "success": true + }, + { + "mutex_wait_ns": 511, + "serialization_ns": 99986, + "serialized_bytes": 1300, + "statement_ns": 446924, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 3027426, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=1", + "COMPILER=gcc-11.4.0", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_PTHREADS", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "HTTP", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 87917039, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 19240859, + 19437522, + 19390137, + 19326619, + 19472547, + 32038020, + 65459205, + 66845669, + 73295204, + 74482278, + 74509031, + 73692338, + 74811943, + 75662483, + 74674682, + 75084060, + 74321331, + 75331225, + 76367724, + 74717520, + 78799954, + 78432027, + 78925388, + 85210276, + 86134143, + 86238093, + 85391741, + 85402267, + 85980171, + 85492513, + 86506863, + 85546887 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 11360849, + 52358431, + 196386, + 151723 + ], + "failures": 0, + "in_window_samples": 2, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 11360849, + "end_ns": 21790530, + "in_window": true, + "scheduled_ns": null, + "start_ns": 10429681, + "success": true + }, + { + "elapsed_ns": 52358431, + "end_ns": 84231345, + "in_window": true, + "scheduled_ns": null, + "start_ns": 31872914, + "success": true + }, + { + "elapsed_ns": 196386, + "end_ns": 94507150, + "in_window": false, + "scheduled_ns": null, + "start_ns": 94310764, + "success": true + }, + { + "elapsed_ns": 151723, + "end_ns": 104731639, + "in_window": false, + "scheduled_ns": null, + "start_ns": 104579916, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 7904333, + 45536244, + 17002199, + 1024156, + 1112471, + 1421738 + ], + "failures": 0, + "in_window_samples": 3, + "missed_periods": 5, + "samples": [ + { + "elapsed_ns": 7904333, + "end_ns": 20437072, + "in_window": true, + "scheduled_ns": 12532739, + "start_ns": 20437072, + "success": true + }, + { + "elapsed_ns": 45536244, + "end_ns": 68068983, + "in_window": true, + "scheduled_ns": 22532739, + "start_ns": 68068983, + "success": true + }, + { + "elapsed_ns": 17002199, + "end_ns": 89534938, + "in_window": true, + "scheduled_ns": 72532739, + "start_ns": 89534938, + "success": true + }, + { + "elapsed_ns": 1024156, + "end_ns": 93556895, + "in_window": false, + "scheduled_ns": 92532739, + "start_ns": 93556895, + "success": true + }, + { + "elapsed_ns": 1112471, + "end_ns": 103645210, + "in_window": false, + "scheduled_ns": 102532739, + "start_ns": 103645210, + "success": true + }, + { + "elapsed_ns": 1421738, + "end_ns": 113954477, + "in_window": false, + "scheduled_ns": 112532739, + "start_ns": 113954477, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 90467546, + "window_start_ns": 2550507 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 2, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 451, + "serialization_ns": 28163, + "serialized_bytes": 610, + "statement_ns": 470126, + "success": true + }, + { + "mutex_wait_ns": 406017, + "serialization_ns": 27171, + "serialized_bytes": 612, + "statement_ns": 470285, + "success": true + }, + { + "mutex_wait_ns": 451823, + "serialization_ns": 27521, + "serialized_bytes": 610, + "statement_ns": 351285, + "success": true + }, + { + "mutex_wait_ns": 333492, + "serialization_ns": 27942, + "serialized_bytes": 612, + "statement_ns": 397351, + "success": true + }, + { + "mutex_wait_ns": 349943, + "serialization_ns": 45224, + "serialized_bytes": 1034, + "statement_ns": 359661, + "success": true + }, + { + "mutex_wait_ns": 315559, + "serialization_ns": 44242, + "serialized_bytes": 1038, + "statement_ns": 349662, + "success": true + }, + { + "mutex_wait_ns": 283028, + "serialization_ns": 45705, + "serialized_bytes": 1073, + "statement_ns": 376321, + "success": true + }, + { + "mutex_wait_ns": 317853, + "serialization_ns": 45845, + "serialized_bytes": 1077, + "statement_ns": 371132, + "success": true + }, + { + "mutex_wait_ns": 328903, + "serialization_ns": 46847, + "serialized_bytes": 1081, + "statement_ns": 347208, + "success": true + }, + { + "mutex_wait_ns": 301703, + "serialization_ns": 47098, + "serialized_bytes": 1085, + "statement_ns": 394345, + "success": true + }, + { + "mutex_wait_ns": 305199, + "serialization_ns": 77494, + "serialized_bytes": 1296, + "statement_ns": 404925, + "success": true + }, + { + "mutex_wait_ns": 340425, + "serialization_ns": 54151, + "serialized_bytes": 1300, + "statement_ns": 349873, + "success": true + }, + { + "mutex_wait_ns": 421, + "serialization_ns": 42369, + "serialized_bytes": 612, + "statement_ns": 374358, + "success": true + }, + { + "mutex_wait_ns": 160850, + "serialization_ns": 26880, + "serialized_bytes": 610, + "statement_ns": 409544, + "success": true + }, + { + "mutex_wait_ns": 392371, + "serialization_ns": 28404, + "serialized_bytes": 612, + "statement_ns": 493280, + "success": true + }, + { + "mutex_wait_ns": 477781, + "serialization_ns": 27241, + "serialized_bytes": 610, + "statement_ns": 362105, + "success": true + }, + { + "mutex_wait_ns": 319015, + "serialization_ns": 44874, + "serialized_bytes": 1038, + "statement_ns": 411938, + "success": true + }, + { + "mutex_wait_ns": 374919, + "serialization_ns": 44413, + "serialized_bytes": 1034, + "statement_ns": 356775, + "success": true + }, + { + "mutex_wait_ns": 297855, + "serialization_ns": 48230, + "serialized_bytes": 1077, + "statement_ns": 387704, + "success": true + }, + { + "mutex_wait_ns": 323484, + "serialization_ns": 48410, + "serialized_bytes": 1073, + "statement_ns": 414333, + "success": true + }, + { + "mutex_wait_ns": 337188, + "serialization_ns": 80651, + "serialized_bytes": 1085, + "statement_ns": 372074, + "success": true + }, + { + "mutex_wait_ns": 326148, + "serialization_ns": 48811, + "serialized_bytes": 1081, + "statement_ns": 396881, + "success": true + }, + { + "mutex_wait_ns": 334394, + "serialization_ns": 57076, + "serialized_bytes": 1300, + "statement_ns": 374669, + "success": true + }, + { + "mutex_wait_ns": 308946, + "serialization_ns": 60442, + "serialized_bytes": 1296, + "statement_ns": 373407, + "success": true + }, + { + "mutex_wait_ns": 111769, + "serialization_ns": 31668, + "serialized_bytes": 610, + "statement_ns": 442776, + "success": true + }, + { + "mutex_wait_ns": 210252, + "serialization_ns": 29896, + "serialized_bytes": 612, + "statement_ns": 388625, + "success": true + }, + { + "mutex_wait_ns": 370781, + "serialization_ns": 28914, + "serialized_bytes": 610, + "statement_ns": 359501, + "success": true + }, + { + "mutex_wait_ns": 345594, + "serialization_ns": 30347, + "serialized_bytes": 612, + "statement_ns": 342038, + "success": true + }, + { + "mutex_wait_ns": 301212, + "serialization_ns": 48801, + "serialized_bytes": 1034, + "statement_ns": 344252, + "success": true + }, + { + "mutex_wait_ns": 301092, + "serialization_ns": 44222, + "serialized_bytes": 1038, + "statement_ns": 402210, + "success": true + }, + { + "mutex_wait_ns": 302995, + "serialization_ns": 79398, + "serialized_bytes": 1073, + "statement_ns": 347518, + "success": true + }, + { + "mutex_wait_ns": 284160, + "serialization_ns": 48130, + "serialized_bytes": 1077, + "statement_ns": 363057, + "success": true + }, + { + "mutex_wait_ns": 315658, + "serialization_ns": 55313, + "serialized_bytes": 1081, + "statement_ns": 352237, + "success": true + }, + { + "mutex_wait_ns": 310299, + "serialization_ns": 49021, + "serialized_bytes": 1085, + "statement_ns": 339123, + "success": true + }, + { + "mutex_wait_ns": 267870, + "serialization_ns": 60253, + "serialized_bytes": 1296, + "statement_ns": 432536, + "success": true + }, + { + "mutex_wait_ns": 366894, + "serialization_ns": 62186, + "serialized_bytes": 1300, + "statement_ns": 347609, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 27451, + "serialized_bytes": 612, + "statement_ns": 404845, + "success": true + }, + { + "mutex_wait_ns": 411, + "serialization_ns": 30687, + "serialized_bytes": 612, + "statement_ns": 414423, + "success": true + }, + { + "mutex_wait_ns": 420464, + "serialization_ns": 27362, + "serialized_bytes": 612, + "statement_ns": 330766, + "success": true + }, + { + "mutex_wait_ns": 320567, + "serialization_ns": 27542, + "serialized_bytes": 612, + "statement_ns": 326640, + "success": true + }, + { + "mutex_wait_ns": 283168, + "serialization_ns": 44433, + "serialized_bytes": 1038, + "statement_ns": 367345, + "success": true + }, + { + "mutex_wait_ns": 292826, + "serialization_ns": 75961, + "serialized_bytes": 1038, + "statement_ns": 336548, + "success": true + }, + { + "mutex_wait_ns": 273991, + "serialization_ns": 46557, + "serialized_bytes": 1077, + "statement_ns": 367225, + "success": true + }, + { + "mutex_wait_ns": 305851, + "serialization_ns": 45915, + "serialized_bytes": 1077, + "statement_ns": 342108, + "success": true + }, + { + "mutex_wait_ns": 298657, + "serialization_ns": 46567, + "serialized_bytes": 1085, + "statement_ns": 328783, + "success": true + }, + { + "mutex_wait_ns": 292715, + "serialization_ns": 46587, + "serialized_bytes": 1085, + "statement_ns": 369860, + "success": true + }, + { + "mutex_wait_ns": 311020, + "serialization_ns": 53880, + "serialized_bytes": 1300, + "statement_ns": 362085, + "success": true + }, + { + "mutex_wait_ns": 305149, + "serialization_ns": 53890, + "serialized_bytes": 1300, + "statement_ns": 367255, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 27000, + "serialized_bytes": 612, + "statement_ns": 384347, + "success": true + }, + { + "mutex_wait_ns": 342358, + "serialization_ns": 26901, + "serialized_bytes": 610, + "statement_ns": 2960091, + "success": true + }, + { + "mutex_wait_ns": 2948269, + "serialization_ns": 27842, + "serialized_bytes": 612, + "statement_ns": 482088, + "success": true + }, + { + "mutex_wait_ns": 463735, + "serialization_ns": 34104, + "serialized_bytes": 610, + "statement_ns": 450380, + "success": true + }, + { + "mutex_wait_ns": 408432, + "serialization_ns": 44153, + "serialized_bytes": 1038, + "statement_ns": 364824, + "success": true + }, + { + "mutex_wait_ns": 320981, + "serialization_ns": 46577, + "serialized_bytes": 1034, + "statement_ns": 431305, + "success": true + }, + { + "mutex_wait_ns": 339834, + "serialization_ns": 84328, + "serialized_bytes": 1077, + "statement_ns": 357937, + "success": true + }, + { + "mutex_wait_ns": 260697, + "serialization_ns": 86681, + "serialized_bytes": 1073, + "statement_ns": 391971, + "success": true + }, + { + "mutex_wait_ns": 318665, + "serialization_ns": 89056, + "serialized_bytes": 1085, + "statement_ns": 354461, + "success": true + }, + { + "mutex_wait_ns": 280724, + "serialization_ns": 89196, + "serialized_bytes": 1081, + "statement_ns": 359721, + "success": true + }, + { + "mutex_wait_ns": 245678, + "serialization_ns": 100398, + "serialized_bytes": 1300, + "statement_ns": 441634, + "success": true + }, + { + "mutex_wait_ns": 344182, + "serialization_ns": 97852, + "serialized_bytes": 1296, + "statement_ns": 371293, + "success": true + }, + { + "mutex_wait_ns": 138488, + "serialization_ns": 41528, + "serialized_bytes": 610, + "statement_ns": 448005, + "success": true + }, + { + "mutex_wait_ns": 321, + "serialization_ns": 48430, + "serialized_bytes": 612, + "statement_ns": 411818, + "success": true + }, + { + "mutex_wait_ns": 378606, + "serialization_ns": 45976, + "serialized_bytes": 610, + "statement_ns": 329926, + "success": true + }, + { + "mutex_wait_ns": 296323, + "serialization_ns": 47669, + "serialized_bytes": 612, + "statement_ns": 385949, + "success": true + }, + { + "mutex_wait_ns": 280533, + "serialization_ns": 106599, + "serialized_bytes": 1034, + "statement_ns": 352758, + "success": true + }, + { + "mutex_wait_ns": 274231, + "serialization_ns": 79769, + "serialized_bytes": 1038, + "statement_ns": 367636, + "success": true + }, + { + "mutex_wait_ns": 271367, + "serialization_ns": 82233, + "serialized_bytes": 1073, + "statement_ns": 359340, + "success": true + }, + { + "mutex_wait_ns": 265004, + "serialization_ns": 82404, + "serialized_bytes": 1077, + "statement_ns": 349031, + "success": true + }, + { + "mutex_wait_ns": 268841, + "serialization_ns": 84698, + "serialized_bytes": 1081, + "statement_ns": 371644, + "success": true + }, + { + "mutex_wait_ns": 291684, + "serialization_ns": 83976, + "serialized_bytes": 1085, + "statement_ns": 369520, + "success": true + }, + { + "mutex_wait_ns": 255587, + "serialization_ns": 100077, + "serialized_bytes": 1296, + "statement_ns": 420975, + "success": true + }, + { + "mutex_wait_ns": 320073, + "serialization_ns": 97823, + "serialized_bytes": 1300, + "statement_ns": 400701, + "success": true + }, + { + "mutex_wait_ns": 199572, + "serialization_ns": 26740, + "serialized_bytes": 610, + "statement_ns": 405266, + "success": true + }, + { + "mutex_wait_ns": 177090, + "serialization_ns": 28133, + "serialized_bytes": 612, + "statement_ns": 439550, + "success": true + }, + { + "mutex_wait_ns": 413171, + "serialization_ns": 48030, + "serialized_bytes": 610, + "statement_ns": 328352, + "success": true + }, + { + "mutex_wait_ns": 301723, + "serialization_ns": 48360, + "serialized_bytes": 612, + "statement_ns": 376973, + "success": true + }, + { + "mutex_wait_ns": 303596, + "serialization_ns": 80851, + "serialized_bytes": 1034, + "statement_ns": 352377, + "success": true + }, + { + "mutex_wait_ns": 281224, + "serialization_ns": 79208, + "serialized_bytes": 1038, + "statement_ns": 375029, + "success": true + }, + { + "mutex_wait_ns": 270144, + "serialization_ns": 82824, + "serialized_bytes": 1073, + "statement_ns": 395007, + "success": true + }, + { + "mutex_wait_ns": 291604, + "serialization_ns": 88665, + "serialized_bytes": 1077, + "statement_ns": 355704, + "success": true + }, + { + "mutex_wait_ns": 279962, + "serialization_ns": 87804, + "serialized_bytes": 1081, + "statement_ns": 395247, + "success": true + }, + { + "mutex_wait_ns": 322482, + "serialization_ns": 85049, + "serialized_bytes": 1085, + "statement_ns": 412198, + "success": true + }, + { + "mutex_wait_ns": 302514, + "serialization_ns": 101890, + "serialized_bytes": 1296, + "statement_ns": 402150, + "success": true + }, + { + "mutex_wait_ns": 289820, + "serialization_ns": 99496, + "serialized_bytes": 1300, + "statement_ns": 423330, + "success": true + }, + { + "mutex_wait_ns": 46406, + "serialization_ns": 27982, + "serialized_bytes": 612, + "statement_ns": 409263, + "success": true + }, + { + "mutex_wait_ns": 180116, + "serialization_ns": 28633, + "serialized_bytes": 612, + "statement_ns": 423641, + "success": true + }, + { + "mutex_wait_ns": 396300, + "serialization_ns": 48019, + "serialized_bytes": 612, + "statement_ns": 332920, + "success": true + }, + { + "mutex_wait_ns": 304899, + "serialization_ns": 48390, + "serialized_bytes": 612, + "statement_ns": 336377, + "success": true + }, + { + "mutex_wait_ns": 255446, + "serialization_ns": 80951, + "serialized_bytes": 1038, + "statement_ns": 385059, + "success": true + }, + { + "mutex_wait_ns": 314847, + "serialization_ns": 78747, + "serialized_bytes": 1038, + "statement_ns": 349041, + "success": true + }, + { + "mutex_wait_ns": 250186, + "serialization_ns": 83546, + "serialized_bytes": 1077, + "statement_ns": 373216, + "success": true + }, + { + "mutex_wait_ns": 276345, + "serialization_ns": 81372, + "serialized_bytes": 1077, + "statement_ns": 364290, + "success": true + }, + { + "mutex_wait_ns": 289199, + "serialization_ns": 85249, + "serialized_bytes": 1085, + "statement_ns": 346687, + "success": true + }, + { + "mutex_wait_ns": 268281, + "serialization_ns": 83315, + "serialized_bytes": 1085, + "statement_ns": 393674, + "success": true + }, + { + "mutex_wait_ns": 283839, + "serialization_ns": 103614, + "serialized_bytes": 1300, + "statement_ns": 396419, + "success": true + }, + { + "mutex_wait_ns": 283408, + "serialization_ns": 106158, + "serialized_bytes": 1300, + "statement_ns": 366564, + "success": true + }, + { + "mutex_wait_ns": 142425, + "serialization_ns": 46547, + "serialized_bytes": 612, + "statement_ns": 432677, + "success": true + }, + { + "mutex_wait_ns": 204482, + "serialization_ns": 26970, + "serialized_bytes": 612, + "statement_ns": 363137, + "success": true + }, + { + "mutex_wait_ns": 330236, + "serialization_ns": 46386, + "serialized_bytes": 612, + "statement_ns": 346376, + "success": true + }, + { + "mutex_wait_ns": 320017, + "serialization_ns": 47449, + "serialized_bytes": 612, + "statement_ns": 328272, + "success": true + }, + { + "mutex_wait_ns": 254144, + "serialization_ns": 80841, + "serialized_bytes": 1038, + "statement_ns": 336558, + "success": true + }, + { + "mutex_wait_ns": 257490, + "serialization_ns": 79368, + "serialized_bytes": 1038, + "statement_ns": 386090, + "success": true + }, + { + "mutex_wait_ns": 259264, + "serialization_ns": 104795, + "serialized_bytes": 1077, + "statement_ns": 372004, + "success": true + }, + { + "mutex_wait_ns": 267870, + "serialization_ns": 81742, + "serialized_bytes": 1077, + "statement_ns": 376803, + "success": true + }, + { + "mutex_wait_ns": 301142, + "serialization_ns": 86812, + "serialized_bytes": 1085, + "statement_ns": 340254, + "success": true + }, + { + "mutex_wait_ns": 267399, + "serialization_ns": 84778, + "serialized_bytes": 1085, + "statement_ns": 341858, + "success": true + }, + { + "mutex_wait_ns": 227734, + "serialization_ns": 100127, + "serialized_bytes": 1300, + "statement_ns": 430423, + "success": true + }, + { + "mutex_wait_ns": 326900, + "serialization_ns": 98353, + "serialized_bytes": 1300, + "statement_ns": 369980, + "success": true + }, + { + "mutex_wait_ns": 118280, + "serialization_ns": 46477, + "serialized_bytes": 612, + "statement_ns": 426856, + "success": true + }, + { + "mutex_wait_ns": 196076, + "serialization_ns": 26780, + "serialized_bytes": 612, + "statement_ns": 387392, + "success": true + }, + { + "mutex_wait_ns": 359210, + "serialization_ns": 47398, + "serialized_bytes": 612, + "statement_ns": 368648, + "success": true + }, + { + "mutex_wait_ns": 332771, + "serialization_ns": 48410, + "serialized_bytes": 612, + "statement_ns": 353650, + "success": true + }, + { + "mutex_wait_ns": 281055, + "serialization_ns": 80580, + "serialized_bytes": 1038, + "statement_ns": 360001, + "success": true + }, + { + "mutex_wait_ns": 288598, + "serialization_ns": 79959, + "serialized_bytes": 1038, + "statement_ns": 362025, + "success": true + }, + { + "mutex_wait_ns": 256118, + "serialization_ns": 83415, + "serialized_bytes": 1077, + "statement_ns": 394806, + "success": true + }, + { + "mutex_wait_ns": 270805, + "serialization_ns": 81472, + "serialized_bytes": 1077, + "statement_ns": 341297, + "success": true + }, + { + "mutex_wait_ns": 260797, + "serialization_ns": 84708, + "serialized_bytes": 1085, + "statement_ns": 369669, + "success": true + }, + { + "mutex_wait_ns": 297485, + "serialization_ns": 83525, + "serialized_bytes": 1085, + "statement_ns": 347979, + "success": true + }, + { + "mutex_wait_ns": 241611, + "serialization_ns": 100438, + "serialized_bytes": 1300, + "statement_ns": 382253, + "success": true + }, + { + "mutex_wait_ns": 271867, + "serialization_ns": 98013, + "serialized_bytes": 1300, + "statement_ns": 407941, + "success": true + }, + { + "mutex_wait_ns": 115305, + "serialization_ns": 36448, + "serialized_bytes": 612, + "statement_ns": 611901, + "success": true + }, + { + "mutex_wait_ns": 370551, + "serialization_ns": 37309, + "serialized_bytes": 612, + "statement_ns": 547011, + "success": true + }, + { + "mutex_wait_ns": 488641, + "serialization_ns": 71824, + "serialized_bytes": 612, + "statement_ns": 396399, + "success": true + }, + { + "mutex_wait_ns": 360923, + "serialization_ns": 48079, + "serialized_bytes": 612, + "statement_ns": 399726, + "success": true + }, + { + "mutex_wait_ns": 295041, + "serialization_ns": 105006, + "serialized_bytes": 1038, + "statement_ns": 363598, + "success": true + }, + { + "mutex_wait_ns": 285933, + "serialization_ns": 79118, + "serialized_bytes": 1038, + "statement_ns": 364910, + "success": true + }, + { + "mutex_wait_ns": 264704, + "serialization_ns": 84017, + "serialized_bytes": 1077, + "statement_ns": 387713, + "success": true + }, + { + "mutex_wait_ns": 288338, + "serialization_ns": 83516, + "serialized_bytes": 1077, + "statement_ns": 349371, + "success": true + }, + { + "mutex_wait_ns": 264593, + "serialization_ns": 88756, + "serialized_bytes": 1085, + "statement_ns": 388635, + "success": true + }, + { + "mutex_wait_ns": 312272, + "serialization_ns": 87894, + "serialized_bytes": 1085, + "statement_ns": 391761, + "success": true + }, + { + "mutex_wait_ns": 274431, + "serialization_ns": 103233, + "serialized_bytes": 1300, + "statement_ns": 486289, + "success": true + }, + { + "mutex_wait_ns": 371971, + "serialization_ns": 102000, + "serialized_bytes": 1300, + "statement_ns": 371446, + "success": true + }, + { + "mutex_wait_ns": 168462, + "serialization_ns": 27000, + "serialized_bytes": 610, + "statement_ns": 459287, + "success": true + }, + { + "mutex_wait_ns": 223647, + "serialization_ns": 28984, + "serialized_bytes": 612, + "statement_ns": 402130, + "success": true + }, + { + "mutex_wait_ns": 373016, + "serialization_ns": 48179, + "serialized_bytes": 610, + "statement_ns": 328603, + "success": true + }, + { + "mutex_wait_ns": 293688, + "serialization_ns": 47879, + "serialized_bytes": 612, + "statement_ns": 364460, + "success": true + }, + { + "mutex_wait_ns": 295722, + "serialization_ns": 79798, + "serialized_bytes": 1034, + "statement_ns": 343801, + "success": true + }, + { + "mutex_wait_ns": 275233, + "serialization_ns": 79618, + "serialized_bytes": 1038, + "statement_ns": 351616, + "success": true + }, + { + "mutex_wait_ns": 244937, + "serialization_ns": 82804, + "serialized_bytes": 1073, + "statement_ns": 390919, + "success": true + }, + { + "mutex_wait_ns": 261959, + "serialization_ns": 107280, + "serialized_bytes": 1077, + "statement_ns": 336627, + "success": true + }, + { + "mutex_wait_ns": 254785, + "serialization_ns": 84988, + "serialized_bytes": 1081, + "statement_ns": 388825, + "success": true + }, + { + "mutex_wait_ns": 318935, + "serialization_ns": 83917, + "serialized_bytes": 1085, + "statement_ns": 344983, + "success": true + }, + { + "mutex_wait_ns": 239195, + "serialization_ns": 99927, + "serialized_bytes": 1296, + "statement_ns": 382213, + "success": true + }, + { + "mutex_wait_ns": 271606, + "serialization_ns": 98865, + "serialized_bytes": 1300, + "statement_ns": 396099, + "success": true + }, + { + "mutex_wait_ns": 52128, + "serialization_ns": 27040, + "serialized_bytes": 610, + "statement_ns": 401649, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 47168, + "serialized_bytes": 610, + "statement_ns": 380189, + "success": true + }, + { + "mutex_wait_ns": 137486, + "serialization_ns": 36598, + "serialized_bytes": 612, + "statement_ns": 406959, + "success": true + }, + { + "mutex_wait_ns": 337900, + "serialization_ns": 79969, + "serialized_bytes": 1034, + "statement_ns": 359190, + "success": true + }, + { + "mutex_wait_ns": 325438, + "serialization_ns": 47047, + "serialized_bytes": 612, + "statement_ns": 475587, + "success": true + }, + { + "mutex_wait_ns": 345755, + "serialization_ns": 107190, + "serialized_bytes": 1073, + "statement_ns": 398743, + "success": true + }, + { + "mutex_wait_ns": 319376, + "serialization_ns": 79087, + "serialized_bytes": 1038, + "statement_ns": 413872, + "success": true + }, + { + "mutex_wait_ns": 344533, + "serialization_ns": 84358, + "serialized_bytes": 1081, + "statement_ns": 372684, + "success": true + }, + { + "mutex_wait_ns": 278900, + "serialization_ns": 82454, + "serialized_bytes": 1077, + "statement_ns": 346045, + "success": true + }, + { + "mutex_wait_ns": 253022, + "serialization_ns": 99936, + "serialized_bytes": 1296, + "statement_ns": 447595, + "success": true + }, + { + "mutex_wait_ns": 365141, + "serialization_ns": 83595, + "serialized_bytes": 1085, + "statement_ns": 553252, + "success": true + }, + { + "mutex_wait_ns": 162072, + "serialization_ns": 27081, + "serialized_bytes": 612, + "statement_ns": 404765, + "success": true + }, + { + "mutex_wait_ns": 303135, + "serialization_ns": 98814, + "serialized_bytes": 1300, + "statement_ns": 379037, + "success": true + }, + { + "mutex_wait_ns": 344483, + "serialization_ns": 47448, + "serialized_bytes": 612, + "statement_ns": 406508, + "success": true + }, + { + "mutex_wait_ns": 131646, + "serialization_ns": 52678, + "serialized_bytes": 610, + "statement_ns": 589780, + "success": true + }, + { + "mutex_wait_ns": 509540, + "serialization_ns": 81132, + "serialized_bytes": 1038, + "statement_ns": 456431, + "success": true + }, + { + "mutex_wait_ns": 435663, + "serialization_ns": 47158, + "serialized_bytes": 610, + "statement_ns": 422217, + "success": true + }, + { + "mutex_wait_ns": 327210, + "serialization_ns": 84117, + "serialized_bytes": 1077, + "statement_ns": 398523, + "success": true + }, + { + "mutex_wait_ns": 330857, + "serialization_ns": 79197, + "serialized_bytes": 1034, + "statement_ns": 377094, + "success": true + }, + { + "mutex_wait_ns": 307533, + "serialization_ns": 85600, + "serialized_bytes": 1085, + "statement_ns": 394516, + "success": true + }, + { + "mutex_wait_ns": 300450, + "serialization_ns": 81833, + "serialized_bytes": 1073, + "statement_ns": 441764, + "success": true + }, + { + "mutex_wait_ns": 337870, + "serialization_ns": 100156, + "serialized_bytes": 1300, + "statement_ns": 405787, + "success": true + }, + { + "mutex_wait_ns": 326128, + "serialization_ns": 83907, + "serialized_bytes": 1081, + "statement_ns": 464937, + "success": true + }, + { + "mutex_wait_ns": 411, + "serialization_ns": 101349, + "serialized_bytes": 1296, + "statement_ns": 407339, + "success": true + }, + { + "mutex_wait_ns": 501, + "serialization_ns": 50745, + "serialized_bytes": 612, + "statement_ns": 544175, + "success": true + }, + { + "mutex_wait_ns": 290, + "serialization_ns": 51146, + "serialized_bytes": 612, + "statement_ns": 451420, + "success": true + }, + { + "mutex_wait_ns": 193363, + "serialization_ns": 37660, + "serialized_bytes": 612, + "statement_ns": 448133, + "success": true + }, + { + "mutex_wait_ns": 371134, + "serialization_ns": 81022, + "serialized_bytes": 1038, + "statement_ns": 406075, + "success": true + }, + { + "mutex_wait_ns": 373068, + "serialization_ns": 47428, + "serialized_bytes": 612, + "statement_ns": 398651, + "success": true + }, + { + "mutex_wait_ns": 292067, + "serialization_ns": 84067, + "serialized_bytes": 1077, + "statement_ns": 446140, + "success": true + }, + { + "mutex_wait_ns": 368139, + "serialization_ns": 80250, + "serialized_bytes": 1038, + "statement_ns": 476746, + "success": true + }, + { + "mutex_wait_ns": 394729, + "serialization_ns": 86781, + "serialized_bytes": 1085, + "statement_ns": 402498, + "success": true + }, + { + "mutex_wait_ns": 299540, + "serialization_ns": 83266, + "serialized_bytes": 1077, + "statement_ns": 388773, + "success": true + }, + { + "mutex_wait_ns": 279413, + "serialization_ns": 99586, + "serialized_bytes": 1300, + "statement_ns": 395906, + "success": true + }, + { + "mutex_wait_ns": 318205, + "serialization_ns": 84919, + "serialized_bytes": 1085, + "statement_ns": 440485, + "success": true + }, + { + "mutex_wait_ns": 310, + "serialization_ns": 66795, + "serialized_bytes": 1300, + "statement_ns": 421938, + "success": true + }, + { + "mutex_wait_ns": 122548, + "serialization_ns": 27562, + "serialized_bytes": 612, + "statement_ns": 458956, + "success": true + }, + { + "mutex_wait_ns": 187540, + "serialization_ns": 53209, + "serialized_bytes": 610, + "statement_ns": 421756, + "success": true + }, + { + "mutex_wait_ns": 405667, + "serialization_ns": 27571, + "serialized_bytes": 612, + "statement_ns": 374068, + "success": true + }, + { + "mutex_wait_ns": 357506, + "serialization_ns": 32852, + "serialized_bytes": 610, + "statement_ns": 338963, + "success": true + }, + { + "mutex_wait_ns": 302053, + "serialization_ns": 43932, + "serialized_bytes": 1038, + "statement_ns": 349081, + "success": true + }, + { + "mutex_wait_ns": 303205, + "serialization_ns": 46757, + "serialized_bytes": 1034, + "statement_ns": 383946, + "success": true + }, + { + "mutex_wait_ns": 292696, + "serialization_ns": 74860, + "serialized_bytes": 1077, + "statement_ns": 352007, + "success": true + }, + { + "mutex_wait_ns": 287286, + "serialization_ns": 49132, + "serialized_bytes": 1073, + "statement_ns": 421616, + "success": true + }, + { + "mutex_wait_ns": 375761, + "serialization_ns": 46527, + "serialized_bytes": 1085, + "statement_ns": 424261, + "success": true + }, + { + "mutex_wait_ns": 376713, + "serialization_ns": 49051, + "serialized_bytes": 1081, + "statement_ns": 350534, + "success": true + }, + { + "mutex_wait_ns": 286204, + "serialization_ns": 54742, + "serialized_bytes": 1300, + "statement_ns": 431314, + "success": true + }, + { + "mutex_wait_ns": 327991, + "serialization_ns": 93124, + "serialized_bytes": 1296, + "statement_ns": 363438, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 2913494, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=1", + "COMPILER=gcc-11.4.0", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_PTHREADS", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "HTTP", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 193332402, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 126619833, + 134021699, + 135090201, + 134915642, + 135020683, + 143654505, + 149781821, + 152382831, + 150102807, + 153722170, + 153914351, + 154263500, + 154289711, + 154341334, + 154564229, + 155914858, + 160893185, + 160386800, + 158431302, + 161231576, + 160909982, + 162123487, + 168156738, + 168309443, + 174096750, + 173227044, + 180175076, + 180675767, + 184981948, + 186730118, + 187707180, + 189889643 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 45052806, + 29890754, + 53214357, + 180096, + 170478, + 171018, + 190626, + 176539 + ], + "failures": 0, + "in_window_samples": 6, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 45052806, + "end_ns": 55441595, + "in_window": true, + "scheduled_ns": null, + "start_ns": 10388789, + "success": true + }, + { + "elapsed_ns": 29890754, + "end_ns": 95401078, + "in_window": true, + "scheduled_ns": null, + "start_ns": 65510324, + "success": true + }, + { + "elapsed_ns": 53214357, + "end_ns": 158701176, + "in_window": true, + "scheduled_ns": null, + "start_ns": 105486819, + "success": true + }, + { + "elapsed_ns": 180096, + "end_ns": 168957615, + "in_window": true, + "scheduled_ns": null, + "start_ns": 168777519, + "success": true + }, + { + "elapsed_ns": 170478, + "end_ns": 179219935, + "in_window": true, + "scheduled_ns": null, + "start_ns": 179049457, + "success": true + }, + { + "elapsed_ns": 171018, + "end_ns": 189481042, + "in_window": true, + "scheduled_ns": null, + "start_ns": 189310024, + "success": true + }, + { + "elapsed_ns": 190626, + "end_ns": 199752600, + "in_window": false, + "scheduled_ns": null, + "start_ns": 199561974, + "success": true + }, + { + "elapsed_ns": 176539, + "end_ns": 210007455, + "in_window": false, + "scheduled_ns": null, + "start_ns": 209830916, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 1909492, + 32463808, + 2336360, + 17430872, + 16198765, + 46559073, + 1352040, + 206002, + 876664, + 469815, + 416426, + 672103, + 856347 + ], + "failures": 0, + "in_window_samples": 10, + "missed_periods": 9, + "samples": [ + { + "elapsed_ns": 1909492, + "end_ns": 14386196, + "in_window": true, + "scheduled_ns": 12476704, + "start_ns": 14386196, + "success": true + }, + { + "elapsed_ns": 32463808, + "end_ns": 54940512, + "in_window": true, + "scheduled_ns": 22476704, + "start_ns": 54940512, + "success": true + }, + { + "elapsed_ns": 2336360, + "end_ns": 64813064, + "in_window": true, + "scheduled_ns": 62476704, + "start_ns": 64813064, + "success": true + }, + { + "elapsed_ns": 17430872, + "end_ns": 89907576, + "in_window": true, + "scheduled_ns": 72476704, + "start_ns": 89907576, + "success": true + }, + { + "elapsed_ns": 16198765, + "end_ns": 108675469, + "in_window": true, + "scheduled_ns": 92476704, + "start_ns": 108675469, + "success": true + }, + { + "elapsed_ns": 46559073, + "end_ns": 159035777, + "in_window": true, + "scheduled_ns": 112476704, + "start_ns": 159035777, + "success": true + }, + { + "elapsed_ns": 1352040, + "end_ns": 163828744, + "in_window": true, + "scheduled_ns": 162476704, + "start_ns": 163828744, + "success": true + }, + { + "elapsed_ns": 206002, + "end_ns": 172682706, + "in_window": true, + "scheduled_ns": 172476704, + "start_ns": 172682706, + "success": true + }, + { + "elapsed_ns": 876664, + "end_ns": 183353368, + "in_window": true, + "scheduled_ns": 182476704, + "start_ns": 183353368, + "success": true + }, + { + "elapsed_ns": 469815, + "end_ns": 192946519, + "in_window": true, + "scheduled_ns": 192476704, + "start_ns": 192946519, + "success": true + }, + { + "elapsed_ns": 416426, + "end_ns": 202893130, + "in_window": false, + "scheduled_ns": 202476704, + "start_ns": 202893130, + "success": true + }, + { + "elapsed_ns": 672103, + "end_ns": 213148807, + "in_window": false, + "scheduled_ns": 212476704, + "start_ns": 213148807, + "success": true + }, + { + "elapsed_ns": 856347, + "end_ns": 223333051, + "in_window": false, + "scheduled_ns": 222476704, + "start_ns": 223333051, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 195825432, + "window_start_ns": 2493030 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 0, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 742, + "serialization_ns": 55173, + "serialized_bytes": 613, + "statement_ns": 633261, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 28864, + "serialized_bytes": 613, + "statement_ns": 426316, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 45645, + "serialized_bytes": 1040, + "statement_ns": 1260130, + "success": true + }, + { + "mutex_wait_ns": 230, + "serialization_ns": 45605, + "serialized_bytes": 1079, + "statement_ns": 537913, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 46868, + "serialized_bytes": 1087, + "statement_ns": 397872, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 53279, + "serialized_bytes": 1302, + "statement_ns": 420705, + "success": true + }, + { + "mutex_wait_ns": 380, + "serialization_ns": 26560, + "serialized_bytes": 611, + "statement_ns": 430143, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 26679, + "serialized_bytes": 611, + "statement_ns": 441022, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 43191, + "serialized_bytes": 1036, + "statement_ns": 373537, + "success": true + }, + { + "mutex_wait_ns": 240, + "serialization_ns": 44874, + "serialized_bytes": 1075, + "statement_ns": 519509, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 45946, + "serialized_bytes": 1083, + "statement_ns": 418030, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53219, + "serialized_bytes": 1298, + "statement_ns": 455760, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 27261, + "serialized_bytes": 611, + "statement_ns": 455950, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 56695, + "serialized_bytes": 611, + "statement_ns": 405677, + "success": true + }, + { + "mutex_wait_ns": 161, + "serialization_ns": 43210, + "serialized_bytes": 1036, + "statement_ns": 385499, + "success": true + }, + { + "mutex_wait_ns": 376452, + "serialization_ns": 27641, + "serialized_bytes": 613, + "statement_ns": 434741, + "success": true + }, + { + "mutex_wait_ns": 381071, + "serialization_ns": 45705, + "serialized_bytes": 1075, + "statement_ns": 454097, + "success": true + }, + { + "mutex_wait_ns": 443827, + "serialization_ns": 27822, + "serialized_bytes": 613, + "statement_ns": 337089, + "success": true + }, + { + "mutex_wait_ns": 298807, + "serialization_ns": 45826, + "serialized_bytes": 1083, + "statement_ns": 335305, + "success": true + }, + { + "mutex_wait_ns": 291183, + "serialization_ns": 44202, + "serialized_bytes": 1040, + "statement_ns": 454198, + "success": true + }, + { + "mutex_wait_ns": 376963, + "serialization_ns": 73277, + "serialized_bytes": 1298, + "statement_ns": 375320, + "success": true + }, + { + "mutex_wait_ns": 318304, + "serialization_ns": 46025, + "serialized_bytes": 1079, + "statement_ns": 461030, + "success": true + }, + { + "mutex_wait_ns": 34715, + "serialization_ns": 83476, + "serialized_bytes": 611, + "statement_ns": 428609, + "success": true + }, + { + "mutex_wait_ns": 379648, + "serialization_ns": 53660, + "serialized_bytes": 1087, + "statement_ns": 377594, + "success": true + }, + { + "mutex_wait_ns": 361754, + "serialization_ns": 27221, + "serialized_bytes": 611, + "statement_ns": 400808, + "success": true + }, + { + "mutex_wait_ns": 279411, + "serialization_ns": 113581, + "serialized_bytes": 1302, + "statement_ns": 373327, + "success": true + }, + { + "mutex_wait_ns": 316591, + "serialization_ns": 65021, + "serialized_bytes": 1036, + "statement_ns": 408013, + "success": true + }, + { + "mutex_wait_ns": 380, + "serialization_ns": 26971, + "serialized_bytes": 613, + "statement_ns": 400677, + "success": true + }, + { + "mutex_wait_ns": 391020, + "serialization_ns": 45725, + "serialized_bytes": 1075, + "statement_ns": 491546, + "success": true + }, + { + "mutex_wait_ns": 481779, + "serialization_ns": 27451, + "serialized_bytes": 613, + "statement_ns": 489854, + "success": true + }, + { + "mutex_wait_ns": 453185, + "serialization_ns": 45706, + "serialized_bytes": 1083, + "statement_ns": 394556, + "success": true + }, + { + "mutex_wait_ns": 357587, + "serialization_ns": 44613, + "serialized_bytes": 1040, + "statement_ns": 363859, + "success": true + }, + { + "mutex_wait_ns": 304147, + "serialization_ns": 54302, + "serialized_bytes": 1298, + "statement_ns": 385449, + "success": true + }, + { + "mutex_wait_ns": 323363, + "serialization_ns": 45786, + "serialized_bytes": 1079, + "statement_ns": 378155, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 46637, + "serialized_bytes": 1087, + "statement_ns": 384417, + "success": true + }, + { + "mutex_wait_ns": 521, + "serialization_ns": 55574, + "serialized_bytes": 1302, + "statement_ns": 422688, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 26690, + "serialized_bytes": 613, + "statement_ns": 458304, + "success": true + }, + { + "mutex_wait_ns": 451, + "serialization_ns": 38181, + "serialized_bytes": 613, + "statement_ns": 459597, + "success": true + }, + { + "mutex_wait_ns": 443988, + "serialization_ns": 27591, + "serialized_bytes": 613, + "statement_ns": 333863, + "success": true + }, + { + "mutex_wait_ns": 323032, + "serialization_ns": 27551, + "serialized_bytes": 613, + "statement_ns": 339063, + "success": true + }, + { + "mutex_wait_ns": 295662, + "serialization_ns": 43541, + "serialized_bytes": 1040, + "statement_ns": 408411, + "success": true + }, + { + "mutex_wait_ns": 373176, + "serialization_ns": 43732, + "serialized_bytes": 1040, + "statement_ns": 363127, + "success": true + }, + { + "mutex_wait_ns": 309838, + "serialization_ns": 45525, + "serialized_bytes": 1079, + "statement_ns": 425443, + "success": true + }, + { + "mutex_wait_ns": 367555, + "serialization_ns": 48410, + "serialized_bytes": 1079, + "statement_ns": 339674, + "success": true + }, + { + "mutex_wait_ns": 302695, + "serialization_ns": 46296, + "serialized_bytes": 1087, + "statement_ns": 340544, + "success": true + }, + { + "mutex_wait_ns": 297215, + "serialization_ns": 46326, + "serialized_bytes": 1087, + "statement_ns": 343400, + "success": true + }, + { + "mutex_wait_ns": 280584, + "serialization_ns": 53369, + "serialized_bytes": 1302, + "statement_ns": 376261, + "success": true + }, + { + "mutex_wait_ns": 312122, + "serialization_ns": 54181, + "serialized_bytes": 1302, + "statement_ns": 352197, + "success": true + }, + { + "mutex_wait_ns": 350, + "serialization_ns": 27261, + "serialized_bytes": 611, + "statement_ns": 373617, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 28934, + "serialized_bytes": 611, + "statement_ns": 346085, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 28563, + "serialized_bytes": 613, + "statement_ns": 418160, + "success": true + }, + { + "mutex_wait_ns": 427026, + "serialization_ns": 46266, + "serialized_bytes": 1036, + "statement_ns": 340015, + "success": true + }, + { + "mutex_wait_ns": 323122, + "serialization_ns": 27121, + "serialized_bytes": 613, + "statement_ns": 356676, + "success": true + }, + { + "mutex_wait_ns": 261257, + "serialization_ns": 79900, + "serialized_bytes": 1075, + "statement_ns": 368577, + "success": true + }, + { + "mutex_wait_ns": 325898, + "serialization_ns": 43551, + "serialized_bytes": 1040, + "statement_ns": 394886, + "success": true + }, + { + "mutex_wait_ns": 351486, + "serialization_ns": 46055, + "serialized_bytes": 1083, + "statement_ns": 352738, + "success": true + }, + { + "mutex_wait_ns": 291583, + "serialization_ns": 45816, + "serialized_bytes": 1079, + "statement_ns": 359501, + "success": true + }, + { + "mutex_wait_ns": 295802, + "serialization_ns": 53590, + "serialized_bytes": 1298, + "statement_ns": 406117, + "success": true + }, + { + "mutex_wait_ns": 369750, + "serialization_ns": 45876, + "serialized_bytes": 1087, + "statement_ns": 359851, + "success": true + }, + { + "mutex_wait_ns": 251, + "serialization_ns": 54271, + "serialized_bytes": 1302, + "statement_ns": 376422, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 28663, + "serialized_bytes": 613, + "statement_ns": 435813, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 27562, + "serialized_bytes": 613, + "statement_ns": 352888, + "success": true + }, + { + "mutex_wait_ns": 390, + "serialization_ns": 39725, + "serialized_bytes": 613, + "statement_ns": 3262455, + "success": true + }, + { + "mutex_wait_ns": 3231917, + "serialization_ns": 43732, + "serialized_bytes": 1040, + "statement_ns": 568581, + "success": true + }, + { + "mutex_wait_ns": 563220, + "serialization_ns": 34364, + "serialized_bytes": 613, + "statement_ns": 426436, + "success": true + }, + { + "mutex_wait_ns": 354471, + "serialization_ns": 56896, + "serialized_bytes": 1079, + "statement_ns": 394556, + "success": true + }, + { + "mutex_wait_ns": 341076, + "serialization_ns": 43381, + "serialized_bytes": 1040, + "statement_ns": 418260, + "success": true + }, + { + "mutex_wait_ns": 374990, + "serialization_ns": 46196, + "serialized_bytes": 1087, + "statement_ns": 389606, + "success": true + }, + { + "mutex_wait_ns": 333061, + "serialization_ns": 45786, + "serialized_bytes": 1079, + "statement_ns": 408041, + "success": true + }, + { + "mutex_wait_ns": 339292, + "serialization_ns": 56746, + "serialized_bytes": 1302, + "statement_ns": 412690, + "success": true + }, + { + "mutex_wait_ns": 367937, + "serialization_ns": 46747, + "serialized_bytes": 1087, + "statement_ns": 484122, + "success": true + }, + { + "mutex_wait_ns": 350, + "serialization_ns": 28514, + "serialized_bytes": 613, + "statement_ns": 392622, + "success": true + }, + { + "mutex_wait_ns": 366123, + "serialization_ns": 53610, + "serialized_bytes": 1302, + "statement_ns": 357857, + "success": true + }, + { + "mutex_wait_ns": 348731, + "serialization_ns": 27221, + "serialized_bytes": 613, + "statement_ns": 336156, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 26971, + "serialized_bytes": 613, + "statement_ns": 463214, + "success": true + }, + { + "mutex_wait_ns": 468033, + "serialization_ns": 43932, + "serialized_bytes": 1040, + "statement_ns": 390438, + "success": true + }, + { + "mutex_wait_ns": 380450, + "serialization_ns": 27391, + "serialized_bytes": 613, + "statement_ns": 341637, + "success": true + }, + { + "mutex_wait_ns": 279260, + "serialization_ns": 46407, + "serialized_bytes": 1079, + "statement_ns": 374238, + "success": true + }, + { + "mutex_wait_ns": 336267, + "serialization_ns": 45916, + "serialized_bytes": 1040, + "statement_ns": 366453, + "success": true + }, + { + "mutex_wait_ns": 329134, + "serialization_ns": 46998, + "serialized_bytes": 1087, + "statement_ns": 449077, + "success": true + }, + { + "mutex_wait_ns": 391019, + "serialization_ns": 48110, + "serialized_bytes": 1079, + "statement_ns": 360863, + "success": true + }, + { + "mutex_wait_ns": 299108, + "serialization_ns": 57136, + "serialized_bytes": 1302, + "statement_ns": 383135, + "success": true + }, + { + "mutex_wait_ns": 336778, + "serialization_ns": 49292, + "serialized_bytes": 1087, + "statement_ns": 394707, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 28373, + "serialized_bytes": 613, + "statement_ns": 383325, + "success": true + }, + { + "mutex_wait_ns": 350023, + "serialization_ns": 60032, + "serialized_bytes": 1302, + "statement_ns": 353279, + "success": true + }, + { + "mutex_wait_ns": 343671, + "serialization_ns": 28513, + "serialized_bytes": 613, + "statement_ns": 349292, + "success": true + }, + { + "mutex_wait_ns": 531, + "serialization_ns": 30267, + "serialized_bytes": 613, + "statement_ns": 377424, + "success": true + }, + { + "mutex_wait_ns": 364369, + "serialization_ns": 43862, + "serialized_bytes": 1040, + "statement_ns": 378516, + "success": true + }, + { + "mutex_wait_ns": 366914, + "serialization_ns": 29996, + "serialized_bytes": 613, + "statement_ns": 353890, + "success": true + }, + { + "mutex_wait_ns": 299960, + "serialization_ns": 46075, + "serialized_bytes": 1079, + "statement_ns": 330075, + "success": true + }, + { + "mutex_wait_ns": 280893, + "serialization_ns": 49823, + "serialized_bytes": 1040, + "statement_ns": 374008, + "success": true + }, + { + "mutex_wait_ns": 338872, + "serialization_ns": 46066, + "serialized_bytes": 1087, + "statement_ns": 344846, + "success": true + }, + { + "mutex_wait_ns": 291700, + "serialization_ns": 48511, + "serialized_bytes": 1079, + "statement_ns": 356114, + "success": true + }, + { + "mutex_wait_ns": 301813, + "serialization_ns": 55784, + "serialized_bytes": 1302, + "statement_ns": 3197413, + "success": true + }, + { + "mutex_wait_ns": 3161927, + "serialization_ns": 52538, + "serialized_bytes": 1087, + "statement_ns": 379077, + "success": true + }, + { + "mutex_wait_ns": 551, + "serialization_ns": 42720, + "serialized_bytes": 613, + "statement_ns": 446943, + "success": true + }, + { + "mutex_wait_ns": 357216, + "serialization_ns": 75071, + "serialized_bytes": 1302, + "statement_ns": 418951, + "success": true + }, + { + "mutex_wait_ns": 395618, + "serialization_ns": 36168, + "serialized_bytes": 613, + "statement_ns": 525500, + "success": true + }, + { + "mutex_wait_ns": 26079, + "serialization_ns": 70801, + "serialized_bytes": 611, + "statement_ns": 445211, + "success": true + }, + { + "mutex_wait_ns": 402581, + "serialization_ns": 45715, + "serialized_bytes": 1040, + "statement_ns": 348830, + "success": true + }, + { + "mutex_wait_ns": 330126, + "serialization_ns": 29956, + "serialized_bytes": 611, + "statement_ns": 408993, + "success": true + }, + { + "mutex_wait_ns": 351756, + "serialization_ns": 48070, + "serialized_bytes": 1079, + "statement_ns": 379076, + "success": true + }, + { + "mutex_wait_ns": 343491, + "serialization_ns": 43521, + "serialized_bytes": 1036, + "statement_ns": 358358, + "success": true + }, + { + "mutex_wait_ns": 315699, + "serialization_ns": 51737, + "serialized_bytes": 1087, + "statement_ns": 368066, + "success": true + }, + { + "mutex_wait_ns": 312604, + "serialization_ns": 45735, + "serialized_bytes": 1075, + "statement_ns": 352958, + "success": true + }, + { + "mutex_wait_ns": 283298, + "serialization_ns": 60192, + "serialized_bytes": 1302, + "statement_ns": 399966, + "success": true + }, + { + "mutex_wait_ns": 364630, + "serialization_ns": 46988, + "serialized_bytes": 1083, + "statement_ns": 361645, + "success": true + }, + { + "mutex_wait_ns": 441, + "serialization_ns": 43201, + "serialized_bytes": 611, + "statement_ns": 397772, + "success": true + }, + { + "mutex_wait_ns": 347217, + "serialization_ns": 55574, + "serialized_bytes": 1298, + "statement_ns": 359200, + "success": true + }, + { + "mutex_wait_ns": 343951, + "serialization_ns": 31569, + "serialized_bytes": 611, + "statement_ns": 374809, + "success": true + }, + { + "mutex_wait_ns": 380, + "serialization_ns": 29676, + "serialized_bytes": 611, + "statement_ns": 406579, + "success": true + }, + { + "mutex_wait_ns": 402200, + "serialization_ns": 48701, + "serialized_bytes": 1036, + "statement_ns": 341738, + "success": true + }, + { + "mutex_wait_ns": 328773, + "serialization_ns": 29826, + "serialized_bytes": 611, + "statement_ns": 360152, + "success": true + }, + { + "mutex_wait_ns": 292867, + "serialization_ns": 50884, + "serialized_bytes": 1075, + "statement_ns": 430753, + "success": true + }, + { + "mutex_wait_ns": 358949, + "serialization_ns": 49212, + "serialized_bytes": 1036, + "statement_ns": 341186, + "success": true + }, + { + "mutex_wait_ns": 291885, + "serialization_ns": 51486, + "serialized_bytes": 1083, + "statement_ns": 365090, + "success": true + }, + { + "mutex_wait_ns": 312804, + "serialization_ns": 45575, + "serialized_bytes": 1075, + "statement_ns": 345624, + "success": true + }, + { + "mutex_wait_ns": 279361, + "serialization_ns": 64580, + "serialized_bytes": 1298, + "statement_ns": 408271, + "success": true + }, + { + "mutex_wait_ns": 365902, + "serialization_ns": 46086, + "serialized_bytes": 1083, + "statement_ns": 395378, + "success": true + }, + { + "mutex_wait_ns": 350, + "serialization_ns": 75181, + "serialized_bytes": 1298, + "statement_ns": 347939, + "success": true + }, + { + "mutex_wait_ns": 116347, + "serialization_ns": 43231, + "serialized_bytes": 611, + "statement_ns": 422347, + "success": true + }, + { + "mutex_wait_ns": 381, + "serialization_ns": 27792, + "serialized_bytes": 613, + "statement_ns": 416176, + "success": true + }, + { + "mutex_wait_ns": 423049, + "serialization_ns": 30828, + "serialized_bytes": 611, + "statement_ns": 370611, + "success": true + }, + { + "mutex_wait_ns": 361014, + "serialization_ns": 27862, + "serialized_bytes": 613, + "statement_ns": 323503, + "success": true + }, + { + "mutex_wait_ns": 285603, + "serialization_ns": 45876, + "serialized_bytes": 1036, + "statement_ns": 333672, + "success": true + }, + { + "mutex_wait_ns": 291003, + "serialization_ns": 43992, + "serialized_bytes": 1040, + "statement_ns": 364800, + "success": true + }, + { + "mutex_wait_ns": 305420, + "serialization_ns": 48280, + "serialized_bytes": 1075, + "statement_ns": 1158110, + "success": true + }, + { + "mutex_wait_ns": 1107987, + "serialization_ns": 45925, + "serialized_bytes": 1079, + "statement_ns": 797507, + "success": true + }, + { + "mutex_wait_ns": 755058, + "serialization_ns": 51306, + "serialized_bytes": 1083, + "statement_ns": 448616, + "success": true + }, + { + "mutex_wait_ns": 405897, + "serialization_ns": 46486, + "serialized_bytes": 1087, + "statement_ns": 467292, + "success": true + }, + { + "mutex_wait_ns": 389597, + "serialization_ns": 64931, + "serialized_bytes": 1298, + "statement_ns": 430874, + "success": true + }, + { + "mutex_wait_ns": 347258, + "serialization_ns": 80309, + "serialized_bytes": 1302, + "statement_ns": 388535, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 27932, + "serialized_bytes": 613, + "statement_ns": 438107, + "success": true + }, + { + "mutex_wait_ns": 394445, + "serialization_ns": 32471, + "serialized_bytes": 613, + "statement_ns": 400177, + "success": true + }, + { + "mutex_wait_ns": 389156, + "serialization_ns": 27742, + "serialized_bytes": 613, + "statement_ns": 330637, + "success": true + }, + { + "mutex_wait_ns": 313505, + "serialization_ns": 28002, + "serialized_bytes": 613, + "statement_ns": 356064, + "success": true + }, + { + "mutex_wait_ns": 321330, + "serialization_ns": 44733, + "serialized_bytes": 1040, + "statement_ns": 370841, + "success": true + }, + { + "mutex_wait_ns": 338872, + "serialization_ns": 44042, + "serialized_bytes": 1040, + "statement_ns": 441323, + "success": true + }, + { + "mutex_wait_ns": 371673, + "serialization_ns": 46978, + "serialized_bytes": 1079, + "statement_ns": 384026, + "success": true + }, + { + "mutex_wait_ns": 325577, + "serialization_ns": 47399, + "serialized_bytes": 1079, + "statement_ns": 396089, + "success": true + }, + { + "mutex_wait_ns": 336878, + "serialization_ns": 51557, + "serialized_bytes": 1087, + "statement_ns": 368678, + "success": true + }, + { + "mutex_wait_ns": 325817, + "serialization_ns": 46708, + "serialized_bytes": 1087, + "statement_ns": 378967, + "success": true + }, + { + "mutex_wait_ns": 313233, + "serialization_ns": 57498, + "serialized_bytes": 1302, + "statement_ns": 407240, + "success": true + }, + { + "mutex_wait_ns": 342318, + "serialization_ns": 54873, + "serialized_bytes": 1302, + "statement_ns": 387132, + "success": true + }, + { + "mutex_wait_ns": 340, + "serialization_ns": 28934, + "serialized_bytes": 611, + "statement_ns": 422178, + "success": true + }, + { + "mutex_wait_ns": 270234, + "serialization_ns": 28383, + "serialized_bytes": 613, + "statement_ns": 390578, + "success": true + }, + { + "mutex_wait_ns": 378496, + "serialization_ns": 28873, + "serialized_bytes": 611, + "statement_ns": 326619, + "success": true + }, + { + "mutex_wait_ns": 308265, + "serialization_ns": 29115, + "serialized_bytes": 613, + "statement_ns": 368507, + "success": true + }, + { + "mutex_wait_ns": 330406, + "serialization_ns": 46386, + "serialized_bytes": 1036, + "statement_ns": 347599, + "success": true + }, + { + "mutex_wait_ns": 311200, + "serialization_ns": 44934, + "serialized_bytes": 1040, + "statement_ns": 349733, + "success": true + }, + { + "mutex_wait_ns": 285432, + "serialization_ns": 48441, + "serialized_bytes": 1075, + "statement_ns": 386902, + "success": true + }, + { + "mutex_wait_ns": 292154, + "serialization_ns": 78447, + "serialized_bytes": 1079, + "statement_ns": 335396, + "success": true + }, + { + "mutex_wait_ns": 287216, + "serialization_ns": 51866, + "serialized_bytes": 1083, + "statement_ns": 388315, + "success": true + }, + { + "mutex_wait_ns": 343721, + "serialization_ns": 51055, + "serialized_bytes": 1087, + "statement_ns": 339253, + "success": true + }, + { + "mutex_wait_ns": 273961, + "serialization_ns": 60884, + "serialized_bytes": 1298, + "statement_ns": 381912, + "success": true + }, + { + "mutex_wait_ns": 310379, + "serialization_ns": 60714, + "serialized_bytes": 1302, + "statement_ns": 438077, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 32009, + "serialized_bytes": 613, + "statement_ns": 473683, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 32030, + "serialized_bytes": 613, + "statement_ns": 371964, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 46717, + "serialized_bytes": 1040, + "statement_ns": 714332, + "success": true + }, + { + "mutex_wait_ns": 152454, + "serialization_ns": 26810, + "serialized_bytes": 611, + "statement_ns": 553613, + "success": true + }, + { + "mutex_wait_ns": 491868, + "serialization_ns": 46877, + "serialized_bytes": 1079, + "statement_ns": 414553, + "success": true + }, + { + "mutex_wait_ns": 405196, + "serialization_ns": 27190, + "serialized_bytes": 611, + "statement_ns": 348821, + "success": true + }, + { + "mutex_wait_ns": 303687, + "serialization_ns": 47178, + "serialized_bytes": 1087, + "statement_ns": 397000, + "success": true + }, + { + "mutex_wait_ns": 327330, + "serialization_ns": 47098, + "serialized_bytes": 1036, + "statement_ns": 422769, + "success": true + }, + { + "mutex_wait_ns": 356756, + "serialization_ns": 57006, + "serialized_bytes": 1302, + "statement_ns": 438808, + "success": true + }, + { + "mutex_wait_ns": 381261, + "serialization_ns": 46437, + "serialized_bytes": 1075, + "statement_ns": 405797, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 47128, + "serialized_bytes": 1083, + "statement_ns": 449599, + "success": true + }, + { + "mutex_wait_ns": 291563, + "serialization_ns": 29525, + "serialized_bytes": 613, + "statement_ns": 381712, + "success": true + }, + { + "mutex_wait_ns": 321559, + "serialization_ns": 54272, + "serialized_bytes": 1298, + "statement_ns": 482861, + "success": true + }, + { + "mutex_wait_ns": 464937, + "serialization_ns": 28884, + "serialized_bytes": 613, + "statement_ns": 482460, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 49222, + "serialized_bytes": 1040, + "statement_ns": 481749, + "success": true + }, + { + "mutex_wait_ns": 401, + "serialization_ns": 27391, + "serialized_bytes": 613, + "statement_ns": 453245, + "success": true + }, + { + "mutex_wait_ns": 394856, + "serialization_ns": 51797, + "serialized_bytes": 1079, + "statement_ns": 362687, + "success": true + }, + { + "mutex_wait_ns": 368237, + "serialization_ns": 27400, + "serialized_bytes": 613, + "statement_ns": 406188, + "success": true + }, + { + "mutex_wait_ns": 352648, + "serialization_ns": 55674, + "serialized_bytes": 1087, + "statement_ns": 341908, + "success": true + }, + { + "mutex_wait_ns": 299388, + "serialization_ns": 44012, + "serialized_bytes": 1040, + "statement_ns": 386992, + "success": true + }, + { + "mutex_wait_ns": 315929, + "serialization_ns": 65302, + "serialized_bytes": 1302, + "statement_ns": 405726, + "success": true + }, + { + "mutex_wait_ns": 347739, + "serialization_ns": 45946, + "serialized_bytes": 1079, + "statement_ns": 360141, + "success": true + }, + { + "mutex_wait_ns": 431, + "serialization_ns": 107871, + "serialized_bytes": 1087, + "statement_ns": 418490, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 55985, + "serialized_bytes": 1302, + "statement_ns": 424802, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 27801, + "serialized_bytes": 613, + "statement_ns": 483830, + "success": true + }, + { + "mutex_wait_ns": 151, + "serialization_ns": 28232, + "serialized_bytes": 613, + "statement_ns": 356365, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 43602, + "serialized_bytes": 1040, + "statement_ns": 388675, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 45875, + "serialized_bytes": 1079, + "statement_ns": 381712, + "success": true + }, + { + "mutex_wait_ns": 390649, + "serialization_ns": 27621, + "serialized_bytes": 613, + "statement_ns": 380099, + "success": true + }, + { + "mutex_wait_ns": 336948, + "serialization_ns": 46697, + "serialized_bytes": 1087, + "statement_ns": 329986, + "success": true + }, + { + "mutex_wait_ns": 313385, + "serialization_ns": 27812, + "serialized_bytes": 613, + "statement_ns": 340204, + "success": true + }, + { + "mutex_wait_ns": 284200, + "serialization_ns": 54241, + "serialized_bytes": 1302, + "statement_ns": 383345, + "success": true + }, + { + "mutex_wait_ns": 347037, + "serialization_ns": 44333, + "serialized_bytes": 1040, + "statement_ns": 345505, + "success": true + }, + { + "mutex_wait_ns": 260, + "serialization_ns": 46256, + "serialized_bytes": 1079, + "statement_ns": 389587, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47378, + "serialized_bytes": 1087, + "statement_ns": 351686, + "success": true + }, + { + "mutex_wait_ns": 301, + "serialization_ns": 90919, + "serialized_bytes": 1302, + "statement_ns": 431314, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 2054562, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=1", + "COMPILER=gcc-11.4.0", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_PTHREADS", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "TLS", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 140938174, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 92391885, + 96884644, + 100946417, + 101489480, + 102968449, + 102863845, + 103808349, + 103174706, + 103694867, + 102914361, + 104161776, + 104750264, + 106137000, + 104189008, + 104894873, + 112089553, + 113269715, + 113209042, + 110729308, + 111001274, + 112795460, + 112324783, + 116487945, + 119971832, + 120942986, + 123113454, + 126351323, + 129296825, + 131594121, + 133626882, + 135279414, + 138455006 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 4209651, + 30906676, + 42793449, + 153867, + 149008, + 146624, + 162533, + 158495 + ], + "failures": 0, + "in_window_samples": 6, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 4209651, + "end_ns": 14650931, + "in_window": true, + "scheduled_ns": null, + "start_ns": 10441280, + "success": true + }, + { + "elapsed_ns": 30906676, + "end_ns": 55644760, + "in_window": true, + "scheduled_ns": null, + "start_ns": 24738084, + "success": true + }, + { + "elapsed_ns": 42793449, + "end_ns": 108512548, + "in_window": true, + "scheduled_ns": null, + "start_ns": 65719099, + "success": true + }, + { + "elapsed_ns": 153867, + "end_ns": 118736306, + "in_window": true, + "scheduled_ns": null, + "start_ns": 118582439, + "success": true + }, + { + "elapsed_ns": 149008, + "end_ns": 128962919, + "in_window": true, + "scheduled_ns": null, + "start_ns": 128813911, + "success": true + }, + { + "elapsed_ns": 146624, + "end_ns": 139187579, + "in_window": true, + "scheduled_ns": null, + "start_ns": 139040955, + "success": true + }, + { + "elapsed_ns": 162533, + "end_ns": 149425122, + "in_window": false, + "scheduled_ns": null, + "start_ns": 149262589, + "success": true + }, + { + "elapsed_ns": 158495, + "end_ns": 159659139, + "in_window": false, + "scheduled_ns": null, + "start_ns": 159500644, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 973576, + 18735483, + 62195997, + 2564449, + 772346, + 1027193, + 757480, + 1019819, + 1224712, + 1405188 + ], + "failures": 0, + "in_window_samples": 7, + "missed_periods": 7, + "samples": [ + { + "elapsed_ns": 973576, + "end_ns": 12507982, + "in_window": true, + "scheduled_ns": 11534406, + "start_ns": 12507982, + "success": true + }, + { + "elapsed_ns": 18735483, + "end_ns": 40269889, + "in_window": true, + "scheduled_ns": 21534406, + "start_ns": 40269889, + "success": true + }, + { + "elapsed_ns": 62195997, + "end_ns": 103730403, + "in_window": true, + "scheduled_ns": 41534406, + "start_ns": 103730403, + "success": true + }, + { + "elapsed_ns": 2564449, + "end_ns": 114098855, + "in_window": true, + "scheduled_ns": 111534406, + "start_ns": 114098855, + "success": true + }, + { + "elapsed_ns": 772346, + "end_ns": 122306752, + "in_window": true, + "scheduled_ns": 121534406, + "start_ns": 122306752, + "success": true + }, + { + "elapsed_ns": 1027193, + "end_ns": 132561599, + "in_window": true, + "scheduled_ns": 131534406, + "start_ns": 132561599, + "success": true + }, + { + "elapsed_ns": 757480, + "end_ns": 142291886, + "in_window": true, + "scheduled_ns": 141534406, + "start_ns": 142291886, + "success": true + }, + { + "elapsed_ns": 1019819, + "end_ns": 152554225, + "in_window": false, + "scheduled_ns": 151534406, + "start_ns": 152554225, + "success": true + }, + { + "elapsed_ns": 1224712, + "end_ns": 162759118, + "in_window": false, + "scheduled_ns": 161534406, + "start_ns": 162759118, + "success": true + }, + { + "elapsed_ns": 1405188, + "end_ns": 172939594, + "in_window": false, + "scheduled_ns": 171534406, + "start_ns": 172939594, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 142492102, + "window_start_ns": 1553928 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 1, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 571, + "serialization_ns": 30237, + "serialized_bytes": 613, + "statement_ns": 578409, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 27511, + "serialized_bytes": 613, + "statement_ns": 391931, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 45044, + "serialized_bytes": 1040, + "statement_ns": 397963, + "success": true + }, + { + "mutex_wait_ns": 331, + "serialization_ns": 45505, + "serialized_bytes": 1079, + "statement_ns": 412189, + "success": true + }, + { + "mutex_wait_ns": 150, + "serialization_ns": 46236, + "serialized_bytes": 1087, + "statement_ns": 456251, + "success": true + }, + { + "mutex_wait_ns": 211, + "serialization_ns": 53279, + "serialized_bytes": 1302, + "statement_ns": 403683, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28073, + "serialized_bytes": 611, + "statement_ns": 486287, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 27451, + "serialized_bytes": 611, + "statement_ns": 387283, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 46056, + "serialized_bytes": 1036, + "statement_ns": 389677, + "success": true + }, + { + "mutex_wait_ns": 291, + "serialization_ns": 48340, + "serialized_bytes": 1075, + "statement_ns": 390008, + "success": true + }, + { + "mutex_wait_ns": 381, + "serialization_ns": 102711, + "serialized_bytes": 1083, + "statement_ns": 363518, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 53931, + "serialized_bytes": 1298, + "statement_ns": 343410, + "success": true + }, + { + "mutex_wait_ns": 431, + "serialization_ns": 27671, + "serialized_bytes": 613, + "statement_ns": 481899, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 27792, + "serialized_bytes": 613, + "statement_ns": 381642, + "success": true + }, + { + "mutex_wait_ns": 118410, + "serialization_ns": 27422, + "serialized_bytes": 613, + "statement_ns": 475778, + "success": true + }, + { + "mutex_wait_ns": 434210, + "serialization_ns": 44062, + "serialized_bytes": 1040, + "statement_ns": 378065, + "success": true + }, + { + "mutex_wait_ns": 362656, + "serialization_ns": 28152, + "serialized_bytes": 613, + "statement_ns": 352839, + "success": true + }, + { + "mutex_wait_ns": 289179, + "serialization_ns": 46397, + "serialized_bytes": 1079, + "statement_ns": 383175, + "success": true + }, + { + "mutex_wait_ns": 340265, + "serialization_ns": 43832, + "serialized_bytes": 1040, + "statement_ns": 354561, + "success": true + }, + { + "mutex_wait_ns": 310729, + "serialization_ns": 46787, + "serialized_bytes": 1087, + "statement_ns": 341808, + "success": true + }, + { + "mutex_wait_ns": 278810, + "serialization_ns": 45825, + "serialized_bytes": 1079, + "statement_ns": 441824, + "success": true + }, + { + "mutex_wait_ns": 334143, + "serialization_ns": 97783, + "serialized_bytes": 1302, + "statement_ns": 379848, + "success": true + }, + { + "mutex_wait_ns": 341056, + "serialization_ns": 46567, + "serialized_bytes": 1087, + "statement_ns": 388014, + "success": true + }, + { + "mutex_wait_ns": 251, + "serialization_ns": 54171, + "serialized_bytes": 1302, + "statement_ns": 410586, + "success": true + }, + { + "mutex_wait_ns": 390, + "serialization_ns": 27211, + "serialized_bytes": 613, + "statement_ns": 429552, + "success": true + }, + { + "mutex_wait_ns": 103673, + "serialization_ns": 47418, + "serialized_bytes": 611, + "statement_ns": 382023, + "success": true + }, + { + "mutex_wait_ns": 365913, + "serialization_ns": 26980, + "serialized_bytes": 613, + "statement_ns": 393483, + "success": true + }, + { + "mutex_wait_ns": 383956, + "serialization_ns": 27681, + "serialized_bytes": 611, + "statement_ns": 357657, + "success": true + }, + { + "mutex_wait_ns": 323082, + "serialization_ns": 43732, + "serialized_bytes": 1040, + "statement_ns": 374408, + "success": true + }, + { + "mutex_wait_ns": 338612, + "serialization_ns": 43941, + "serialized_bytes": 1036, + "statement_ns": 368527, + "success": true + }, + { + "mutex_wait_ns": 296183, + "serialization_ns": 52608, + "serialized_bytes": 1079, + "statement_ns": 346776, + "success": true + }, + { + "mutex_wait_ns": 285303, + "serialization_ns": 45514, + "serialized_bytes": 1075, + "statement_ns": 357486, + "success": true + }, + { + "mutex_wait_ns": 320188, + "serialization_ns": 46106, + "serialized_bytes": 1087, + "statement_ns": 374859, + "success": true + }, + { + "mutex_wait_ns": 338311, + "serialization_ns": 46206, + "serialized_bytes": 1083, + "statement_ns": 368868, + "success": true + }, + { + "mutex_wait_ns": 304308, + "serialization_ns": 54722, + "serialized_bytes": 1302, + "statement_ns": 453255, + "success": true + }, + { + "mutex_wait_ns": 342228, + "serialization_ns": 54481, + "serialized_bytes": 1298, + "statement_ns": 399616, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 27231, + "serialized_bytes": 613, + "statement_ns": 464386, + "success": true + }, + { + "mutex_wait_ns": 472140, + "serialization_ns": 28523, + "serialized_bytes": 611, + "statement_ns": 422769, + "success": true + }, + { + "mutex_wait_ns": 414013, + "serialization_ns": 27381, + "serialized_bytes": 613, + "statement_ns": 330416, + "success": true + }, + { + "mutex_wait_ns": 320237, + "serialization_ns": 27862, + "serialized_bytes": 611, + "statement_ns": 330436, + "success": true + }, + { + "mutex_wait_ns": 287456, + "serialization_ns": 44192, + "serialized_bytes": 1040, + "statement_ns": 336849, + "success": true + }, + { + "mutex_wait_ns": 299849, + "serialization_ns": 43993, + "serialized_bytes": 1036, + "statement_ns": 357997, + "success": true + }, + { + "mutex_wait_ns": 301653, + "serialization_ns": 45805, + "serialized_bytes": 1079, + "statement_ns": 344583, + "success": true + }, + { + "mutex_wait_ns": 278599, + "serialization_ns": 48170, + "serialized_bytes": 1075, + "statement_ns": 426355, + "success": true + }, + { + "mutex_wait_ns": 390959, + "serialization_ns": 46476, + "serialized_bytes": 1087, + "statement_ns": 652607, + "success": true + }, + { + "mutex_wait_ns": 613344, + "serialization_ns": 51706, + "serialized_bytes": 1083, + "statement_ns": 557270, + "success": true + }, + { + "mutex_wait_ns": 492639, + "serialization_ns": 54672, + "serialized_bytes": 1302, + "statement_ns": 456241, + "success": true + }, + { + "mutex_wait_ns": 385789, + "serialization_ns": 63268, + "serialized_bytes": 1298, + "statement_ns": 384800, + "success": true + }, + { + "mutex_wait_ns": 370, + "serialization_ns": 35276, + "serialized_bytes": 611, + "statement_ns": 443317, + "success": true + }, + { + "mutex_wait_ns": 62807, + "serialization_ns": 32451, + "serialized_bytes": 613, + "statement_ns": 482680, + "success": true + }, + { + "mutex_wait_ns": 472181, + "serialization_ns": 29865, + "serialized_bytes": 611, + "statement_ns": 337079, + "success": true + }, + { + "mutex_wait_ns": 326419, + "serialization_ns": 29815, + "serialized_bytes": 613, + "statement_ns": 364771, + "success": true + }, + { + "mutex_wait_ns": 322982, + "serialization_ns": 43752, + "serialized_bytes": 1036, + "statement_ns": 355343, + "success": true + }, + { + "mutex_wait_ns": 304367, + "serialization_ns": 52388, + "serialized_bytes": 1040, + "statement_ns": 344463, + "success": true + }, + { + "mutex_wait_ns": 283498, + "serialization_ns": 46116, + "serialized_bytes": 1075, + "statement_ns": 352608, + "success": true + }, + { + "mutex_wait_ns": 288878, + "serialization_ns": 54592, + "serialized_bytes": 1079, + "statement_ns": 367275, + "success": true + }, + { + "mutex_wait_ns": 330757, + "serialization_ns": 47489, + "serialized_bytes": 1083, + "statement_ns": 355463, + "success": true + }, + { + "mutex_wait_ns": 302364, + "serialization_ns": 55904, + "serialized_bytes": 1087, + "statement_ns": 396910, + "success": true + }, + { + "mutex_wait_ns": 302905, + "serialization_ns": 55784, + "serialized_bytes": 1298, + "statement_ns": 390298, + "success": true + }, + { + "mutex_wait_ns": 314837, + "serialization_ns": 65322, + "serialized_bytes": 1302, + "statement_ns": 408492, + "success": true + }, + { + "mutex_wait_ns": 380, + "serialization_ns": 36057, + "serialized_bytes": 611, + "statement_ns": 402982, + "success": true + }, + { + "mutex_wait_ns": 151, + "serialization_ns": 28983, + "serialized_bytes": 611, + "statement_ns": 365051, + "success": true + }, + { + "mutex_wait_ns": 275233, + "serialization_ns": 31930, + "serialized_bytes": 613, + "statement_ns": 384708, + "success": true + }, + { + "mutex_wait_ns": 338812, + "serialization_ns": 46076, + "serialized_bytes": 1036, + "statement_ns": 332199, + "success": true + }, + { + "mutex_wait_ns": 313665, + "serialization_ns": 28744, + "serialized_bytes": 613, + "statement_ns": 332430, + "success": true + }, + { + "mutex_wait_ns": 270464, + "serialization_ns": 45565, + "serialized_bytes": 1075, + "statement_ns": 340084, + "success": true + }, + { + "mutex_wait_ns": 294769, + "serialization_ns": 45916, + "serialized_bytes": 1040, + "statement_ns": 334955, + "success": true + }, + { + "mutex_wait_ns": 291564, + "serialization_ns": 46357, + "serialized_bytes": 1083, + "statement_ns": 367084, + "success": true + }, + { + "mutex_wait_ns": 304307, + "serialization_ns": 48100, + "serialized_bytes": 1079, + "statement_ns": 345014, + "success": true + }, + { + "mutex_wait_ns": 283169, + "serialization_ns": 53780, + "serialized_bytes": 1298, + "statement_ns": 378776, + "success": true + }, + { + "mutex_wait_ns": 329495, + "serialization_ns": 51826, + "serialized_bytes": 1087, + "statement_ns": 400597, + "success": true + }, + { + "mutex_wait_ns": 360, + "serialization_ns": 27823, + "serialized_bytes": 611, + "statement_ns": 380981, + "success": true + }, + { + "mutex_wait_ns": 328733, + "serialization_ns": 61445, + "serialized_bytes": 1302, + "statement_ns": 339463, + "success": true + }, + { + "mutex_wait_ns": 324635, + "serialization_ns": 27361, + "serialized_bytes": 611, + "statement_ns": 376633, + "success": true + }, + { + "mutex_wait_ns": 380, + "serialization_ns": 34144, + "serialized_bytes": 613, + "statement_ns": 373266, + "success": true + }, + { + "mutex_wait_ns": 337390, + "serialization_ns": 44433, + "serialized_bytes": 1036, + "statement_ns": 373646, + "success": true + }, + { + "mutex_wait_ns": 352678, + "serialization_ns": 31750, + "serialized_bytes": 613, + "statement_ns": 359891, + "success": true + }, + { + "mutex_wait_ns": 297806, + "serialization_ns": 46436, + "serialized_bytes": 1075, + "statement_ns": 415665, + "success": true + }, + { + "mutex_wait_ns": 379027, + "serialization_ns": 43671, + "serialized_bytes": 1040, + "statement_ns": 349913, + "success": true + }, + { + "mutex_wait_ns": 310179, + "serialization_ns": 48911, + "serialized_bytes": 1083, + "statement_ns": 340234, + "success": true + }, + { + "mutex_wait_ns": 277618, + "serialization_ns": 45976, + "serialized_bytes": 1079, + "statement_ns": 363538, + "success": true + }, + { + "mutex_wait_ns": 302684, + "serialization_ns": 57027, + "serialized_bytes": 1298, + "statement_ns": 372395, + "success": true + }, + { + "mutex_wait_ns": 334775, + "serialization_ns": 46236, + "serialized_bytes": 1087, + "statement_ns": 423419, + "success": true + }, + { + "mutex_wait_ns": 76613, + "serialization_ns": 28273, + "serialized_bytes": 613, + "statement_ns": 2226182, + "success": true + }, + { + "mutex_wait_ns": 2143398, + "serialization_ns": 54261, + "serialized_bytes": 1302, + "statement_ns": 689225, + "success": true + }, + { + "mutex_wait_ns": 674638, + "serialization_ns": 32371, + "serialized_bytes": 613, + "statement_ns": 528326, + "success": true + }, + { + "mutex_wait_ns": 132106, + "serialization_ns": 36929, + "serialized_bytes": 613, + "statement_ns": 407470, + "success": true + }, + { + "mutex_wait_ns": 356154, + "serialization_ns": 52838, + "serialized_bytes": 1040, + "statement_ns": 391711, + "success": true + }, + { + "mutex_wait_ns": 379628, + "serialization_ns": 29916, + "serialized_bytes": 613, + "statement_ns": 374318, + "success": true + }, + { + "mutex_wait_ns": 309818, + "serialization_ns": 54982, + "serialized_bytes": 1079, + "statement_ns": 383746, + "success": true + }, + { + "mutex_wait_ns": 347027, + "serialization_ns": 44333, + "serialized_bytes": 1040, + "statement_ns": 363227, + "success": true + }, + { + "mutex_wait_ns": 316059, + "serialization_ns": 55634, + "serialized_bytes": 1087, + "statement_ns": 355263, + "success": true + }, + { + "mutex_wait_ns": 293046, + "serialization_ns": 46697, + "serialized_bytes": 1079, + "statement_ns": 374108, + "success": true + }, + { + "mutex_wait_ns": 299489, + "serialization_ns": 65372, + "serialized_bytes": 1302, + "statement_ns": 402470, + "success": true + }, + { + "mutex_wait_ns": 356855, + "serialization_ns": 49803, + "serialized_bytes": 1087, + "statement_ns": 436033, + "success": true + }, + { + "mutex_wait_ns": 46196, + "serialization_ns": 64290, + "serialized_bytes": 613, + "statement_ns": 380240, + "success": true + }, + { + "mutex_wait_ns": 310228, + "serialization_ns": 60564, + "serialized_bytes": 1302, + "statement_ns": 407380, + "success": true + }, + { + "mutex_wait_ns": 388194, + "serialization_ns": 30126, + "serialized_bytes": 613, + "statement_ns": 370030, + "success": true + }, + { + "mutex_wait_ns": 380, + "serialization_ns": 29535, + "serialized_bytes": 613, + "statement_ns": 399065, + "success": true + }, + { + "mutex_wait_ns": 395056, + "serialization_ns": 46177, + "serialized_bytes": 1040, + "statement_ns": 375911, + "success": true + }, + { + "mutex_wait_ns": 363478, + "serialization_ns": 29845, + "serialized_bytes": 613, + "statement_ns": 328363, + "success": true + }, + { + "mutex_wait_ns": 267519, + "serialization_ns": 50945, + "serialized_bytes": 1079, + "statement_ns": 368026, + "success": true + }, + { + "mutex_wait_ns": 325697, + "serialization_ns": 43712, + "serialized_bytes": 1040, + "statement_ns": 371002, + "success": true + }, + { + "mutex_wait_ns": 322482, + "serialization_ns": 51927, + "serialized_bytes": 1087, + "statement_ns": 395698, + "success": true + }, + { + "mutex_wait_ns": 334885, + "serialization_ns": 46416, + "serialized_bytes": 1079, + "statement_ns": 419022, + "success": true + }, + { + "mutex_wait_ns": 373076, + "serialization_ns": 60903, + "serialized_bytes": 1302, + "statement_ns": 465929, + "success": true + }, + { + "mutex_wait_ns": 443658, + "serialization_ns": 47789, + "serialized_bytes": 1087, + "statement_ns": 369018, + "success": true + }, + { + "mutex_wait_ns": 350, + "serialization_ns": 32360, + "serialized_bytes": 613, + "statement_ns": 466130, + "success": true + }, + { + "mutex_wait_ns": 441734, + "serialization_ns": 57567, + "serialized_bytes": 1302, + "statement_ns": 603415, + "success": true + }, + { + "mutex_wait_ns": 588097, + "serialization_ns": 30958, + "serialized_bytes": 613, + "statement_ns": 396098, + "success": true + }, + { + "mutex_wait_ns": 401, + "serialization_ns": 36568, + "serialized_bytes": 613, + "statement_ns": 402430, + "success": true + }, + { + "mutex_wait_ns": 350533, + "serialization_ns": 52879, + "serialized_bytes": 1040, + "statement_ns": 397922, + "success": true + }, + { + "mutex_wait_ns": 385278, + "serialization_ns": 30036, + "serialized_bytes": 613, + "statement_ns": 329485, + "success": true + }, + { + "mutex_wait_ns": 265185, + "serialization_ns": 55193, + "serialized_bytes": 1079, + "statement_ns": 343340, + "success": true + }, + { + "mutex_wait_ns": 301051, + "serialization_ns": 44784, + "serialized_bytes": 1040, + "statement_ns": 354732, + "success": true + }, + { + "mutex_wait_ns": 273540, + "serialization_ns": 84608, + "serialized_bytes": 1087, + "statement_ns": 522054, + "success": true + }, + { + "mutex_wait_ns": 460179, + "serialization_ns": 46376, + "serialized_bytes": 1079, + "statement_ns": 556497, + "success": true + }, + { + "mutex_wait_ns": 481858, + "serialization_ns": 65432, + "serialized_bytes": 1302, + "statement_ns": 474295, + "success": true + }, + { + "mutex_wait_ns": 428289, + "serialization_ns": 48811, + "serialized_bytes": 1087, + "statement_ns": 475967, + "success": true + }, + { + "mutex_wait_ns": 63288, + "serialization_ns": 32461, + "serialized_bytes": 611, + "statement_ns": 387713, + "success": true + }, + { + "mutex_wait_ns": 317732, + "serialization_ns": 60233, + "serialized_bytes": 1302, + "statement_ns": 477411, + "success": true + }, + { + "mutex_wait_ns": 462363, + "serialization_ns": 31959, + "serialized_bytes": 611, + "statement_ns": 426085, + "success": true + }, + { + "mutex_wait_ns": 66013, + "serialization_ns": 32822, + "serialized_bytes": 611, + "statement_ns": 480706, + "success": true + }, + { + "mutex_wait_ns": 444148, + "serialization_ns": 44332, + "serialized_bytes": 1036, + "statement_ns": 399255, + "success": true + }, + { + "mutex_wait_ns": 387222, + "serialization_ns": 28573, + "serialized_bytes": 611, + "statement_ns": 367476, + "success": true + }, + { + "mutex_wait_ns": 308646, + "serialization_ns": 48500, + "serialized_bytes": 1075, + "statement_ns": 384978, + "success": true + }, + { + "mutex_wait_ns": 346276, + "serialization_ns": 46065, + "serialized_bytes": 1036, + "statement_ns": 334654, + "success": true + }, + { + "mutex_wait_ns": 286003, + "serialization_ns": 51577, + "serialized_bytes": 1083, + "statement_ns": 381411, + "success": true + }, + { + "mutex_wait_ns": 326189, + "serialization_ns": 48290, + "serialized_bytes": 1075, + "statement_ns": 361744, + "success": true + }, + { + "mutex_wait_ns": 299900, + "serialization_ns": 60423, + "serialized_bytes": 1298, + "statement_ns": 423650, + "success": true + }, + { + "mutex_wait_ns": 391019, + "serialization_ns": 51466, + "serialized_bytes": 1083, + "statement_ns": 423670, + "success": true + }, + { + "mutex_wait_ns": 2214, + "serialization_ns": 54602, + "serialized_bytes": 613, + "statement_ns": 385639, + "success": true + }, + { + "mutex_wait_ns": 296683, + "serialization_ns": 74469, + "serialized_bytes": 1298, + "statement_ns": 358199, + "success": true + }, + { + "mutex_wait_ns": 344593, + "serialization_ns": 32540, + "serialized_bytes": 613, + "statement_ns": 417068, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 44373, + "serialized_bytes": 1040, + "statement_ns": 426044, + "success": true + }, + { + "mutex_wait_ns": 32130, + "serialization_ns": 50013, + "serialized_bytes": 613, + "statement_ns": 430904, + "success": true + }, + { + "mutex_wait_ns": 370711, + "serialization_ns": 46056, + "serialized_bytes": 1079, + "statement_ns": 368427, + "success": true + }, + { + "mutex_wait_ns": 351646, + "serialization_ns": 27401, + "serialized_bytes": 613, + "statement_ns": 369108, + "success": true + }, + { + "mutex_wait_ns": 293267, + "serialization_ns": 78126, + "serialized_bytes": 1087, + "statement_ns": 343711, + "success": true + }, + { + "mutex_wait_ns": 299979, + "serialization_ns": 46317, + "serialized_bytes": 1040, + "statement_ns": 363498, + "success": true + }, + { + "mutex_wait_ns": 295732, + "serialization_ns": 57217, + "serialized_bytes": 1302, + "statement_ns": 390538, + "success": true + }, + { + "mutex_wait_ns": 326028, + "serialization_ns": 48330, + "serialized_bytes": 1079, + "statement_ns": 401349, + "success": true + }, + { + "mutex_wait_ns": 341, + "serialization_ns": 41126, + "serialized_bytes": 613, + "statement_ns": 428880, + "success": true + }, + { + "mutex_wait_ns": 381081, + "serialization_ns": 50184, + "serialized_bytes": 1087, + "statement_ns": 370469, + "success": true + }, + { + "mutex_wait_ns": 354160, + "serialization_ns": 28994, + "serialized_bytes": 613, + "statement_ns": 362066, + "success": true + }, + { + "mutex_wait_ns": 297274, + "serialization_ns": 57477, + "serialized_bytes": 1302, + "statement_ns": 623143, + "success": true + }, + { + "mutex_wait_ns": 582497, + "serialization_ns": 46577, + "serialized_bytes": 1040, + "statement_ns": 378746, + "success": true + }, + { + "mutex_wait_ns": 250, + "serialization_ns": 52068, + "serialized_bytes": 1079, + "statement_ns": 375731, + "success": true + }, + { + "mutex_wait_ns": 25117, + "serialization_ns": 36859, + "serialized_bytes": 611, + "statement_ns": 451171, + "success": true + }, + { + "mutex_wait_ns": 407230, + "serialization_ns": 51757, + "serialized_bytes": 1087, + "statement_ns": 385038, + "success": true + }, + { + "mutex_wait_ns": 367986, + "serialization_ns": 29986, + "serialized_bytes": 611, + "statement_ns": 390098, + "success": true + }, + { + "mutex_wait_ns": 320257, + "serialization_ns": 60544, + "serialized_bytes": 1302, + "statement_ns": 580973, + "success": true + }, + { + "mutex_wait_ns": 543944, + "serialization_ns": 43451, + "serialized_bytes": 1036, + "statement_ns": 539687, + "success": true + }, + { + "mutex_wait_ns": 521, + "serialization_ns": 61505, + "serialized_bytes": 1075, + "statement_ns": 416517, + "success": true + }, + { + "mutex_wait_ns": 307574, + "serialization_ns": 32100, + "serialized_bytes": 613, + "statement_ns": 391650, + "success": true + }, + { + "mutex_wait_ns": 349572, + "serialization_ns": 45786, + "serialized_bytes": 1083, + "statement_ns": 397371, + "success": true + }, + { + "mutex_wait_ns": 382423, + "serialization_ns": 30457, + "serialized_bytes": 613, + "statement_ns": 344543, + "success": true + }, + { + "mutex_wait_ns": 285212, + "serialization_ns": 53770, + "serialized_bytes": 1298, + "statement_ns": 372775, + "success": true + }, + { + "mutex_wait_ns": 329374, + "serialization_ns": 46276, + "serialized_bytes": 1040, + "statement_ns": 358188, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 27611, + "serialized_bytes": 613, + "statement_ns": 391280, + "success": true + }, + { + "mutex_wait_ns": 354011, + "serialization_ns": 48430, + "serialized_bytes": 1079, + "statement_ns": 354350, + "success": true + }, + { + "mutex_wait_ns": 342478, + "serialization_ns": 27482, + "serialized_bytes": 613, + "statement_ns": 325788, + "success": true + }, + { + "mutex_wait_ns": 289621, + "serialization_ns": 51886, + "serialized_bytes": 1087, + "statement_ns": 337119, + "success": true + }, + { + "mutex_wait_ns": 291895, + "serialization_ns": 44212, + "serialized_bytes": 1040, + "statement_ns": 368587, + "success": true + }, + { + "mutex_wait_ns": 247812, + "serialization_ns": 111979, + "serialized_bytes": 1302, + "statement_ns": 382764, + "success": true + }, + { + "mutex_wait_ns": 319015, + "serialization_ns": 48200, + "serialized_bytes": 1079, + "statement_ns": 446989, + "success": true + }, + { + "mutex_wait_ns": 411, + "serialization_ns": 89126, + "serialized_bytes": 1087, + "statement_ns": 416737, + "success": true + }, + { + "mutex_wait_ns": 218658, + "serialization_ns": 28503, + "serialized_bytes": 613, + "statement_ns": 414132, + "success": true + }, + { + "mutex_wait_ns": 306461, + "serialization_ns": 102862, + "serialized_bytes": 1302, + "statement_ns": 354602, + "success": true + }, + { + "mutex_wait_ns": 326148, + "serialization_ns": 49051, + "serialized_bytes": 613, + "statement_ns": 377895, + "success": true + }, + { + "mutex_wait_ns": 401, + "serialization_ns": 80690, + "serialized_bytes": 1040, + "statement_ns": 466460, + "success": true + }, + { + "mutex_wait_ns": 471, + "serialization_ns": 82374, + "serialized_bytes": 1079, + "statement_ns": 499081, + "success": true + }, + { + "mutex_wait_ns": 461, + "serialization_ns": 82825, + "serialized_bytes": 1087, + "statement_ns": 393023, + "success": true + }, + { + "mutex_wait_ns": 431, + "serialization_ns": 96060, + "serialized_bytes": 1302, + "statement_ns": 492448, + "success": true + }, + { + "mutex_wait_ns": 421, + "serialization_ns": 44212, + "serialized_bytes": 611, + "statement_ns": 452434, + "success": true + }, + { + "mutex_wait_ns": 467346, + "serialization_ns": 44183, + "serialized_bytes": 613, + "statement_ns": 370040, + "success": true + }, + { + "mutex_wait_ns": 352307, + "serialization_ns": 27992, + "serialized_bytes": 611, + "statement_ns": 333111, + "success": true + }, + { + "mutex_wait_ns": 314216, + "serialization_ns": 32902, + "serialized_bytes": 613, + "statement_ns": 341306, + "success": true + }, + { + "mutex_wait_ns": 301593, + "serialization_ns": 44503, + "serialized_bytes": 1036, + "statement_ns": 614756, + "success": true + }, + { + "mutex_wait_ns": 568461, + "serialization_ns": 52988, + "serialized_bytes": 1040, + "statement_ns": 410265, + "success": true + }, + { + "mutex_wait_ns": 351465, + "serialization_ns": 46337, + "serialized_bytes": 1075, + "statement_ns": 341387, + "success": true + }, + { + "mutex_wait_ns": 270395, + "serialization_ns": 55293, + "serialized_bytes": 1079, + "statement_ns": 341346, + "success": true + }, + { + "mutex_wait_ns": 297485, + "serialization_ns": 46557, + "serialized_bytes": 1083, + "statement_ns": 342188, + "success": true + }, + { + "mutex_wait_ns": 289239, + "serialization_ns": 55754, + "serialized_bytes": 1087, + "statement_ns": 354452, + "success": true + }, + { + "mutex_wait_ns": 290532, + "serialization_ns": 54492, + "serialized_bytes": 1298, + "statement_ns": 398683, + "success": true + }, + { + "mutex_wait_ns": 285743, + "serialization_ns": 103523, + "serialized_bytes": 1302, + "statement_ns": 389025, + "success": true + }, + { + "mutex_wait_ns": 153757, + "serialization_ns": 48330, + "serialized_bytes": 613, + "statement_ns": 401970, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 27672, + "serialized_bytes": 613, + "statement_ns": 347919, + "success": true + }, + { + "mutex_wait_ns": 421, + "serialization_ns": 45475, + "serialized_bytes": 1040, + "statement_ns": 371883, + "success": true + }, + { + "mutex_wait_ns": 320, + "serialization_ns": 77224, + "serialized_bytes": 1079, + "statement_ns": 366644, + "success": true + }, + { + "mutex_wait_ns": 150, + "serialization_ns": 47369, + "serialized_bytes": 1087, + "statement_ns": 353730, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 54151, + "serialized_bytes": 1302, + "statement_ns": 420605, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 1997976, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=1", + "COMPILER=gcc-11.4.0", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_PTHREADS", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "TLS", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 146341668, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 67286252, + 86227435, + 91542087, + 92495855, + 91553845, + 92794082, + 91675316, + 92208028, + 93275000, + 94435392, + 98401722, + 98813368, + 98092354, + 100673598, + 104964984, + 105691974, + 106373766, + 106446060, + 106363347, + 108665100, + 107464400, + 107873263, + 109601514, + 112648705, + 113322974, + 120428095, + 120838722, + 125533789, + 134335192, + 139064184, + 141176665, + 144023154 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 6258503, + 14224078, + 20957938, + 13760885, + 5429837, + 187259, + 133238, + 133840, + 161131, + 153156 + ], + "failures": 0, + "in_window_samples": 8, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 6258503, + "end_ns": 16657177, + "in_window": true, + "scheduled_ns": null, + "start_ns": 10398674, + "success": true + }, + { + "elapsed_ns": 14224078, + "end_ns": 40967200, + "in_window": true, + "scheduled_ns": null, + "start_ns": 26743122, + "success": true + }, + { + "elapsed_ns": 20957938, + "end_ns": 72013443, + "in_window": true, + "scheduled_ns": null, + "start_ns": 51055505, + "success": true + }, + { + "elapsed_ns": 13760885, + "end_ns": 95855800, + "in_window": true, + "scheduled_ns": null, + "start_ns": 82094915, + "success": true + }, + { + "elapsed_ns": 5429837, + "end_ns": 111367200, + "in_window": true, + "scheduled_ns": null, + "start_ns": 105937363, + "success": true + }, + { + "elapsed_ns": 187259, + "end_ns": 121628066, + "in_window": true, + "scheduled_ns": null, + "start_ns": 121440807, + "success": true + }, + { + "elapsed_ns": 133238, + "end_ns": 131828010, + "in_window": true, + "scheduled_ns": null, + "start_ns": 131694772, + "success": true + }, + { + "elapsed_ns": 133840, + "end_ns": 142035147, + "in_window": true, + "scheduled_ns": null, + "start_ns": 141901307, + "success": true + }, + { + "elapsed_ns": 161131, + "end_ns": 152267962, + "in_window": false, + "scheduled_ns": null, + "start_ns": 152106831, + "success": true + }, + { + "elapsed_ns": 153156, + "end_ns": 162505245, + "in_window": false, + "scheduled_ns": null, + "start_ns": 162352089, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 4942630, + 10864350, + 17850020, + 21490181, + 2217467, + 7513101, + 1652832, + 1221816, + 1460502, + 1168208, + 1867996, + 1112607, + 1314214 + ], + "failures": 0, + "in_window_samples": 10, + "missed_periods": 4, + "samples": [ + { + "elapsed_ns": 4942630, + "end_ns": 17433389, + "in_window": true, + "scheduled_ns": 12490759, + "start_ns": 17433389, + "success": true + }, + { + "elapsed_ns": 10864350, + "end_ns": 33355109, + "in_window": true, + "scheduled_ns": 22490759, + "start_ns": 33355109, + "success": true + }, + { + "elapsed_ns": 17850020, + "end_ns": 60340779, + "in_window": true, + "scheduled_ns": 42490759, + "start_ns": 60340779, + "success": true + }, + { + "elapsed_ns": 21490181, + "end_ns": 83980940, + "in_window": true, + "scheduled_ns": 62490759, + "start_ns": 83980940, + "success": true + }, + { + "elapsed_ns": 2217467, + "end_ns": 94708226, + "in_window": true, + "scheduled_ns": 92490759, + "start_ns": 94708226, + "success": true + }, + { + "elapsed_ns": 7513101, + "end_ns": 110003860, + "in_window": true, + "scheduled_ns": 102490759, + "start_ns": 110003860, + "success": true + }, + { + "elapsed_ns": 1652832, + "end_ns": 114143591, + "in_window": true, + "scheduled_ns": 112490759, + "start_ns": 114143591, + "success": true + }, + { + "elapsed_ns": 1221816, + "end_ns": 123712575, + "in_window": true, + "scheduled_ns": 122490759, + "start_ns": 123712575, + "success": true + }, + { + "elapsed_ns": 1460502, + "end_ns": 133951261, + "in_window": true, + "scheduled_ns": 132490759, + "start_ns": 133951261, + "success": true + }, + { + "elapsed_ns": 1168208, + "end_ns": 143658967, + "in_window": true, + "scheduled_ns": 142490759, + "start_ns": 143658967, + "success": true + }, + { + "elapsed_ns": 1867996, + "end_ns": 154358755, + "in_window": false, + "scheduled_ns": 152490759, + "start_ns": 154358755, + "success": true + }, + { + "elapsed_ns": 1112607, + "end_ns": 163603366, + "in_window": false, + "scheduled_ns": 162490759, + "start_ns": 163603366, + "success": true + }, + { + "elapsed_ns": 1314214, + "end_ns": 173804973, + "in_window": false, + "scheduled_ns": 172490759, + "start_ns": 173804973, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 148850838, + "window_start_ns": 2509170 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 2, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 561, + "serialization_ns": 30227, + "serialized_bytes": 613, + "statement_ns": 623643, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 27972, + "serialized_bytes": 613, + "statement_ns": 395358, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 45094, + "serialized_bytes": 1040, + "statement_ns": 370020, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 45605, + "serialized_bytes": 1079, + "statement_ns": 436624, + "success": true + }, + { + "mutex_wait_ns": 150, + "serialization_ns": 46156, + "serialized_bytes": 1087, + "statement_ns": 358208, + "success": true + }, + { + "mutex_wait_ns": 241, + "serialization_ns": 53680, + "serialized_bytes": 1302, + "statement_ns": 464476, + "success": true + }, + { + "mutex_wait_ns": 391, + "serialization_ns": 28202, + "serialized_bytes": 613, + "statement_ns": 466180, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 27511, + "serialized_bytes": 613, + "statement_ns": 372034, + "success": true + }, + { + "mutex_wait_ns": 140, + "serialization_ns": 43752, + "serialized_bytes": 1040, + "statement_ns": 399616, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 45534, + "serialized_bytes": 1079, + "statement_ns": 410305, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 46467, + "serialized_bytes": 1087, + "statement_ns": 605221, + "success": true + }, + { + "mutex_wait_ns": 341, + "serialization_ns": 56976, + "serialized_bytes": 1302, + "statement_ns": 405875, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 27932, + "serialized_bytes": 613, + "statement_ns": 477821, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 27872, + "serialized_bytes": 613, + "statement_ns": 391621, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 44343, + "serialized_bytes": 1040, + "statement_ns": 365031, + "success": true + }, + { + "mutex_wait_ns": 245949, + "serialization_ns": 27050, + "serialized_bytes": 611, + "statement_ns": 409484, + "success": true + }, + { + "mutex_wait_ns": 354271, + "serialization_ns": 46166, + "serialized_bytes": 1079, + "statement_ns": 372465, + "success": true + }, + { + "mutex_wait_ns": 363208, + "serialization_ns": 27311, + "serialized_bytes": 611, + "statement_ns": 450520, + "success": true + }, + { + "mutex_wait_ns": 406147, + "serialization_ns": 46557, + "serialized_bytes": 1087, + "statement_ns": 367295, + "success": true + }, + { + "mutex_wait_ns": 324655, + "serialization_ns": 43651, + "serialized_bytes": 1036, + "statement_ns": 350103, + "success": true + }, + { + "mutex_wait_ns": 285112, + "serialization_ns": 54582, + "serialized_bytes": 1302, + "statement_ns": 411394, + "success": true + }, + { + "mutex_wait_ns": 350323, + "serialization_ns": 45215, + "serialized_bytes": 1075, + "statement_ns": 385249, + "success": true + }, + { + "mutex_wait_ns": 181, + "serialization_ns": 46306, + "serialized_bytes": 1083, + "statement_ns": 398333, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 54231, + "serialized_bytes": 1298, + "statement_ns": 385329, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 26730, + "serialized_bytes": 611, + "statement_ns": 416266, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 26850, + "serialized_bytes": 611, + "statement_ns": 381502, + "success": true + }, + { + "mutex_wait_ns": 57567, + "serialization_ns": 75641, + "serialized_bytes": 613, + "statement_ns": 385900, + "success": true + }, + { + "mutex_wait_ns": 345274, + "serialization_ns": 43221, + "serialized_bytes": 1036, + "statement_ns": 332600, + "success": true + }, + { + "mutex_wait_ns": 315699, + "serialization_ns": 27581, + "serialized_bytes": 613, + "statement_ns": 364750, + "success": true + }, + { + "mutex_wait_ns": 309146, + "serialization_ns": 45235, + "serialized_bytes": 1075, + "statement_ns": 379267, + "success": true + }, + { + "mutex_wait_ns": 342108, + "serialization_ns": 43932, + "serialized_bytes": 1040, + "statement_ns": 355242, + "success": true + }, + { + "mutex_wait_ns": 312112, + "serialization_ns": 46036, + "serialized_bytes": 1083, + "statement_ns": 388275, + "success": true + }, + { + "mutex_wait_ns": 300109, + "serialization_ns": 45646, + "serialized_bytes": 1079, + "statement_ns": 326319, + "success": true + }, + { + "mutex_wait_ns": 262640, + "serialization_ns": 53730, + "serialized_bytes": 1298, + "statement_ns": 375130, + "success": true + }, + { + "mutex_wait_ns": 331398, + "serialization_ns": 46036, + "serialized_bytes": 1087, + "statement_ns": 420084, + "success": true + }, + { + "mutex_wait_ns": 70602, + "serialization_ns": 27972, + "serialized_bytes": 611, + "statement_ns": 386100, + "success": true + }, + { + "mutex_wait_ns": 322321, + "serialization_ns": 53700, + "serialized_bytes": 1302, + "statement_ns": 430202, + "success": true + }, + { + "mutex_wait_ns": 418741, + "serialization_ns": 27271, + "serialized_bytes": 611, + "statement_ns": 386140, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 43201, + "serialized_bytes": 1036, + "statement_ns": 409454, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 45305, + "serialized_bytes": 1075, + "statement_ns": 387513, + "success": true + }, + { + "mutex_wait_ns": 330, + "serialization_ns": 29766, + "serialized_bytes": 611, + "statement_ns": 433539, + "success": true + }, + { + "mutex_wait_ns": 448557, + "serialization_ns": 50243, + "serialized_bytes": 1083, + "statement_ns": 358098, + "success": true + }, + { + "mutex_wait_ns": 347518, + "serialization_ns": 27461, + "serialized_bytes": 611, + "statement_ns": 332290, + "success": true + }, + { + "mutex_wait_ns": 268411, + "serialization_ns": 54542, + "serialized_bytes": 1298, + "statement_ns": 418550, + "success": true + }, + { + "mutex_wait_ns": 376492, + "serialization_ns": 43371, + "serialized_bytes": 1036, + "statement_ns": 358088, + "success": true + }, + { + "mutex_wait_ns": 380, + "serialization_ns": 42039, + "serialized_bytes": 613, + "statement_ns": 380370, + "success": true + }, + { + "mutex_wait_ns": 321269, + "serialization_ns": 45675, + "serialized_bytes": 1075, + "statement_ns": 355163, + "success": true + }, + { + "mutex_wait_ns": 336768, + "serialization_ns": 28353, + "serialized_bytes": 613, + "statement_ns": 333733, + "success": true + }, + { + "mutex_wait_ns": 289880, + "serialization_ns": 46147, + "serialized_bytes": 1083, + "statement_ns": 369329, + "success": true + }, + { + "mutex_wait_ns": 333431, + "serialization_ns": 43301, + "serialized_bytes": 1040, + "statement_ns": 353570, + "success": true + }, + { + "mutex_wait_ns": 296943, + "serialization_ns": 53721, + "serialized_bytes": 1298, + "statement_ns": 379969, + "success": true + }, + { + "mutex_wait_ns": 325367, + "serialization_ns": 46497, + "serialized_bytes": 1079, + "statement_ns": 465938, + "success": true + }, + { + "mutex_wait_ns": 37670, + "serialization_ns": 49853, + "serialized_bytes": 611, + "statement_ns": 394606, + "success": true + }, + { + "mutex_wait_ns": 349692, + "serialization_ns": 48000, + "serialized_bytes": 1087, + "statement_ns": 366063, + "success": true + }, + { + "mutex_wait_ns": 349241, + "serialization_ns": 27331, + "serialized_bytes": 611, + "statement_ns": 341467, + "success": true + }, + { + "mutex_wait_ns": 276906, + "serialization_ns": 54902, + "serialized_bytes": 1302, + "statement_ns": 500373, + "success": true + }, + { + "mutex_wait_ns": 462573, + "serialization_ns": 43491, + "serialized_bytes": 1036, + "statement_ns": 415425, + "success": true + }, + { + "mutex_wait_ns": 79097, + "serialization_ns": 28534, + "serialized_bytes": 611, + "statement_ns": 381491, + "success": true + }, + { + "mutex_wait_ns": 318715, + "serialization_ns": 45936, + "serialized_bytes": 1075, + "statement_ns": 398192, + "success": true + }, + { + "mutex_wait_ns": 387502, + "serialization_ns": 28163, + "serialized_bytes": 611, + "statement_ns": 342960, + "success": true + }, + { + "mutex_wait_ns": 307183, + "serialization_ns": 46436, + "serialized_bytes": 1083, + "statement_ns": 412740, + "success": true + }, + { + "mutex_wait_ns": 373677, + "serialization_ns": 44834, + "serialized_bytes": 1036, + "statement_ns": 443096, + "success": true + }, + { + "mutex_wait_ns": 384227, + "serialization_ns": 54511, + "serialized_bytes": 1298, + "statement_ns": 373657, + "success": true + }, + { + "mutex_wait_ns": 316971, + "serialization_ns": 48139, + "serialized_bytes": 1075, + "statement_ns": 428640, + "success": true + }, + { + "mutex_wait_ns": 401, + "serialization_ns": 30477, + "serialized_bytes": 613, + "statement_ns": 477080, + "success": true + }, + { + "mutex_wait_ns": 435722, + "serialization_ns": 48871, + "serialized_bytes": 1083, + "statement_ns": 404685, + "success": true + }, + { + "mutex_wait_ns": 391631, + "serialization_ns": 28563, + "serialized_bytes": 613, + "statement_ns": 359891, + "success": true + }, + { + "mutex_wait_ns": 299158, + "serialization_ns": 56846, + "serialized_bytes": 1298, + "statement_ns": 398794, + "success": true + }, + { + "mutex_wait_ns": 356755, + "serialization_ns": 43571, + "serialized_bytes": 1040, + "statement_ns": 377755, + "success": true + }, + { + "mutex_wait_ns": 20367, + "serialization_ns": 40857, + "serialized_bytes": 613, + "statement_ns": 390389, + "success": true + }, + { + "mutex_wait_ns": 328132, + "serialization_ns": 45695, + "serialized_bytes": 1079, + "statement_ns": 406008, + "success": true + }, + { + "mutex_wait_ns": 390739, + "serialization_ns": 32070, + "serialized_bytes": 613, + "statement_ns": 338872, + "success": true + }, + { + "mutex_wait_ns": 301162, + "serialization_ns": 46597, + "serialized_bytes": 1087, + "statement_ns": 408181, + "success": true + }, + { + "mutex_wait_ns": 365342, + "serialization_ns": 44252, + "serialized_bytes": 1040, + "statement_ns": 366413, + "success": true + }, + { + "mutex_wait_ns": 302294, + "serialization_ns": 54622, + "serialized_bytes": 1302, + "statement_ns": 435983, + "success": true + }, + { + "mutex_wait_ns": 382082, + "serialization_ns": 48250, + "serialized_bytes": 1079, + "statement_ns": 456191, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48661, + "serialized_bytes": 1087, + "statement_ns": 380289, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 58539, + "serialized_bytes": 1302, + "statement_ns": 481578, + "success": true + }, + { + "mutex_wait_ns": 1182, + "serialization_ns": 29835, + "serialized_bytes": 613, + "statement_ns": 493070, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 29735, + "serialized_bytes": 613, + "statement_ns": 363408, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 45976, + "serialized_bytes": 1040, + "statement_ns": 416367, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 47909, + "serialized_bytes": 1079, + "statement_ns": 411518, + "success": true + }, + { + "mutex_wait_ns": 160, + "serialization_ns": 48731, + "serialized_bytes": 1087, + "statement_ns": 379518, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 61014, + "serialized_bytes": 1302, + "statement_ns": 399946, + "success": true + }, + { + "mutex_wait_ns": 381, + "serialization_ns": 27320, + "serialized_bytes": 613, + "statement_ns": 569382, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 27030, + "serialized_bytes": 613, + "statement_ns": 551128, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 27862, + "serialized_bytes": 611, + "statement_ns": 517575, + "success": true + }, + { + "mutex_wait_ns": 505733, + "serialization_ns": 43571, + "serialized_bytes": 1040, + "statement_ns": 438017, + "success": true + }, + { + "mutex_wait_ns": 423660, + "serialization_ns": 27452, + "serialized_bytes": 611, + "statement_ns": 360993, + "success": true + }, + { + "mutex_wait_ns": 300912, + "serialization_ns": 45484, + "serialized_bytes": 1079, + "statement_ns": 374408, + "success": true + }, + { + "mutex_wait_ns": 331358, + "serialization_ns": 44203, + "serialized_bytes": 1036, + "statement_ns": 390087, + "success": true + }, + { + "mutex_wait_ns": 346957, + "serialization_ns": 45975, + "serialized_bytes": 1087, + "statement_ns": 353910, + "success": true + }, + { + "mutex_wait_ns": 290522, + "serialization_ns": 45965, + "serialized_bytes": 1075, + "statement_ns": 370832, + "success": true + }, + { + "mutex_wait_ns": 328282, + "serialization_ns": 53570, + "serialized_bytes": 1302, + "statement_ns": 447575, + "success": true + }, + { + "mutex_wait_ns": 382895, + "serialization_ns": 46947, + "serialized_bytes": 1083, + "statement_ns": 366243, + "success": true + }, + { + "mutex_wait_ns": 260, + "serialization_ns": 53931, + "serialized_bytes": 1298, + "statement_ns": 401449, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 27301, + "serialized_bytes": 613, + "statement_ns": 413481, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 27571, + "serialized_bytes": 613, + "statement_ns": 356715, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 43411, + "serialized_bytes": 1040, + "statement_ns": 378306, + "success": true + }, + { + "mutex_wait_ns": 350, + "serialization_ns": 77956, + "serialized_bytes": 1079, + "statement_ns": 374579, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 46006, + "serialized_bytes": 1087, + "statement_ns": 399074, + "success": true + }, + { + "mutex_wait_ns": 240, + "serialization_ns": 53480, + "serialized_bytes": 1302, + "statement_ns": 461561, + "success": true + }, + { + "mutex_wait_ns": 351, + "serialization_ns": 26730, + "serialized_bytes": 613, + "statement_ns": 441984, + "success": true + }, + { + "mutex_wait_ns": 447124, + "serialization_ns": 27050, + "serialized_bytes": 613, + "statement_ns": 385489, + "success": true + }, + { + "mutex_wait_ns": 369900, + "serialization_ns": 27401, + "serialized_bytes": 613, + "statement_ns": 354522, + "success": true + }, + { + "mutex_wait_ns": 336408, + "serialization_ns": 27631, + "serialized_bytes": 613, + "statement_ns": 367616, + "success": true + }, + { + "mutex_wait_ns": 295641, + "serialization_ns": 72305, + "serialized_bytes": 1040, + "statement_ns": 343571, + "success": true + }, + { + "mutex_wait_ns": 300110, + "serialization_ns": 43952, + "serialized_bytes": 1040, + "statement_ns": 420183, + "success": true + }, + { + "mutex_wait_ns": 358308, + "serialization_ns": 45895, + "serialized_bytes": 1079, + "statement_ns": 362697, + "success": true + }, + { + "mutex_wait_ns": 300220, + "serialization_ns": 46016, + "serialized_bytes": 1079, + "statement_ns": 342168, + "success": true + }, + { + "mutex_wait_ns": 297985, + "serialization_ns": 47048, + "serialized_bytes": 1087, + "statement_ns": 407751, + "success": true + }, + { + "mutex_wait_ns": 364189, + "serialization_ns": 46296, + "serialized_bytes": 1087, + "statement_ns": 501245, + "success": true + }, + { + "mutex_wait_ns": 437496, + "serialization_ns": 54071, + "serialized_bytes": 1302, + "statement_ns": 401479, + "success": true + }, + { + "mutex_wait_ns": 337499, + "serialization_ns": 53670, + "serialized_bytes": 1302, + "statement_ns": 424462, + "success": true + }, + { + "mutex_wait_ns": 62426, + "serialization_ns": 31990, + "serialized_bytes": 611, + "statement_ns": 409013, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 27592, + "serialized_bytes": 611, + "statement_ns": 358088, + "success": true + }, + { + "mutex_wait_ns": 342709, + "serialization_ns": 27582, + "serialized_bytes": 613, + "statement_ns": 364299, + "success": true + }, + { + "mutex_wait_ns": 322531, + "serialization_ns": 44072, + "serialized_bytes": 1036, + "statement_ns": 2641146, + "success": true + }, + { + "mutex_wait_ns": 2626087, + "serialization_ns": 27452, + "serialized_bytes": 613, + "statement_ns": 493871, + "success": true + }, + { + "mutex_wait_ns": 430312, + "serialization_ns": 49934, + "serialized_bytes": 1075, + "statement_ns": 518066, + "success": true + }, + { + "mutex_wait_ns": 424512, + "serialization_ns": 96640, + "serialized_bytes": 1040, + "statement_ns": 419252, + "success": true + }, + { + "mutex_wait_ns": 366934, + "serialization_ns": 52047, + "serialized_bytes": 1083, + "statement_ns": 405983, + "success": true + }, + { + "mutex_wait_ns": 296526, + "serialization_ns": 97071, + "serialized_bytes": 1079, + "statement_ns": 413842, + "success": true + }, + { + "mutex_wait_ns": 301993, + "serialization_ns": 101399, + "serialized_bytes": 1298, + "statement_ns": 446242, + "success": true + }, + { + "mutex_wait_ns": 368718, + "serialization_ns": 89076, + "serialized_bytes": 1087, + "statement_ns": 411698, + "success": true + }, + { + "mutex_wait_ns": 452, + "serialization_ns": 100517, + "serialized_bytes": 1302, + "statement_ns": 427687, + "success": true + }, + { + "mutex_wait_ns": 429942, + "serialization_ns": 43251, + "serialized_bytes": 611, + "statement_ns": 467361, + "success": true + }, + { + "mutex_wait_ns": 320, + "serialization_ns": 51046, + "serialized_bytes": 611, + "statement_ns": 411037, + "success": true + }, + { + "mutex_wait_ns": 404264, + "serialization_ns": 40465, + "serialized_bytes": 611, + "statement_ns": 339193, + "success": true + }, + { + "mutex_wait_ns": 303236, + "serialization_ns": 48070, + "serialized_bytes": 611, + "statement_ns": 344702, + "success": true + }, + { + "mutex_wait_ns": 262950, + "serialization_ns": 79759, + "serialized_bytes": 1036, + "statement_ns": 415726, + "success": true + }, + { + "mutex_wait_ns": 347148, + "serialization_ns": 78627, + "serialized_bytes": 1036, + "statement_ns": 363628, + "success": true + }, + { + "mutex_wait_ns": 265525, + "serialization_ns": 83777, + "serialized_bytes": 1075, + "statement_ns": 364980, + "success": true + }, + { + "mutex_wait_ns": 267288, + "serialization_ns": 82033, + "serialized_bytes": 1075, + "statement_ns": 361925, + "success": true + }, + { + "mutex_wait_ns": 281735, + "serialization_ns": 84889, + "serialized_bytes": 1083, + "statement_ns": 341136, + "success": true + }, + { + "mutex_wait_ns": 260837, + "serialization_ns": 84297, + "serialized_bytes": 1083, + "statement_ns": 383835, + "success": true + }, + { + "mutex_wait_ns": 282596, + "serialization_ns": 99306, + "serialized_bytes": 1298, + "statement_ns": 387183, + "success": true + }, + { + "mutex_wait_ns": 287366, + "serialization_ns": 98403, + "serialized_bytes": 1298, + "statement_ns": 456074, + "success": true + }, + { + "mutex_wait_ns": 571, + "serialization_ns": 61104, + "serialized_bytes": 613, + "statement_ns": 373377, + "success": true + }, + { + "mutex_wait_ns": 272929, + "serialization_ns": 31809, + "serialized_bytes": 613, + "statement_ns": 414403, + "success": true + }, + { + "mutex_wait_ns": 399596, + "serialization_ns": 27090, + "serialized_bytes": 613, + "statement_ns": 370471, + "success": true + }, + { + "mutex_wait_ns": 349532, + "serialization_ns": 32631, + "serialized_bytes": 613, + "statement_ns": 368808, + "success": true + }, + { + "mutex_wait_ns": 320598, + "serialization_ns": 49573, + "serialized_bytes": 1040, + "statement_ns": 454116, + "success": true + }, + { + "mutex_wait_ns": 415144, + "serialization_ns": 46497, + "serialized_bytes": 1040, + "statement_ns": 358238, + "success": true + }, + { + "mutex_wait_ns": 302515, + "serialization_ns": 45825, + "serialized_bytes": 1079, + "statement_ns": 380760, + "success": true + }, + { + "mutex_wait_ns": 322452, + "serialization_ns": 48410, + "serialized_bytes": 1079, + "statement_ns": 345775, + "success": true + }, + { + "mutex_wait_ns": 310288, + "serialization_ns": 46517, + "serialized_bytes": 1087, + "statement_ns": 353270, + "success": true + }, + { + "mutex_wait_ns": 296993, + "serialization_ns": 53360, + "serialized_bytes": 1087, + "statement_ns": 420595, + "success": true + }, + { + "mutex_wait_ns": 363548, + "serialization_ns": 53631, + "serialized_bytes": 1302, + "statement_ns": 565474, + "success": true + }, + { + "mutex_wait_ns": 501175, + "serialization_ns": 60733, + "serialized_bytes": 1302, + "statement_ns": 499822, + "success": true + }, + { + "mutex_wait_ns": 461, + "serialization_ns": 67696, + "serialized_bytes": 613, + "statement_ns": 432186, + "success": true + }, + { + "mutex_wait_ns": 310, + "serialization_ns": 47489, + "serialized_bytes": 613, + "statement_ns": 386872, + "success": true + }, + { + "mutex_wait_ns": 201, + "serialization_ns": 44313, + "serialized_bytes": 1040, + "statement_ns": 424481, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 46607, + "serialized_bytes": 1079, + "statement_ns": 367496, + "success": true + }, + { + "mutex_wait_ns": 191, + "serialization_ns": 46356, + "serialized_bytes": 1087, + "statement_ns": 433568, + "success": true + }, + { + "mutex_wait_ns": 371, + "serialization_ns": 27942, + "serialized_bytes": 613, + "statement_ns": 364409, + "success": true + }, + { + "mutex_wait_ns": 337630, + "serialization_ns": 54461, + "serialized_bytes": 1302, + "statement_ns": 343490, + "success": true + }, + { + "mutex_wait_ns": 326920, + "serialization_ns": 27411, + "serialized_bytes": 613, + "statement_ns": 334894, + "success": true + }, + { + "mutex_wait_ns": 210, + "serialization_ns": 44043, + "serialized_bytes": 1040, + "statement_ns": 336518, + "success": true + }, + { + "mutex_wait_ns": 346927, + "serialization_ns": 27360, + "serialized_bytes": 613, + "statement_ns": 425474, + "success": true + }, + { + "mutex_wait_ns": 364039, + "serialization_ns": 45896, + "serialized_bytes": 1079, + "statement_ns": 331709, + "success": true + }, + { + "mutex_wait_ns": 314577, + "serialization_ns": 27922, + "serialized_bytes": 613, + "statement_ns": 328021, + "success": true + }, + { + "mutex_wait_ns": 284070, + "serialization_ns": 46807, + "serialized_bytes": 1087, + "statement_ns": 380249, + "success": true + }, + { + "mutex_wait_ns": 312152, + "serialization_ns": 68728, + "serialized_bytes": 1040, + "statement_ns": 349482, + "success": true + }, + { + "mutex_wait_ns": 285572, + "serialization_ns": 54251, + "serialized_bytes": 1302, + "statement_ns": 401680, + "success": true + }, + { + "mutex_wait_ns": 344542, + "serialization_ns": 46768, + "serialized_bytes": 1079, + "statement_ns": 427047, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48351, + "serialized_bytes": 1087, + "statement_ns": 429151, + "success": true + }, + { + "mutex_wait_ns": 271, + "serialization_ns": 56085, + "serialized_bytes": 1302, + "statement_ns": 378596, + "success": true + }, + { + "mutex_wait_ns": 451, + "serialization_ns": 64721, + "serialized_bytes": 613, + "statement_ns": 431982, + "success": true + }, + { + "mutex_wait_ns": 281, + "serialization_ns": 48620, + "serialized_bytes": 613, + "statement_ns": 388565, + "success": true + }, + { + "mutex_wait_ns": 246380, + "serialization_ns": 47568, + "serialized_bytes": 613, + "statement_ns": 440612, + "success": true + }, + { + "mutex_wait_ns": 337760, + "serialization_ns": 103122, + "serialized_bytes": 1040, + "statement_ns": 371293, + "success": true + }, + { + "mutex_wait_ns": 345424, + "serialization_ns": 47839, + "serialized_bytes": 613, + "statement_ns": 399997, + "success": true + }, + { + "mutex_wait_ns": 283940, + "serialization_ns": 84647, + "serialized_bytes": 1079, + "statement_ns": 377828, + "success": true + }, + { + "mutex_wait_ns": 295100, + "serialization_ns": 81041, + "serialized_bytes": 1040, + "statement_ns": 355791, + "success": true + }, + { + "mutex_wait_ns": 304785, + "serialization_ns": 49913, + "serialized_bytes": 1087, + "statement_ns": 385389, + "success": true + }, + { + "mutex_wait_ns": 298116, + "serialization_ns": 74188, + "serialized_bytes": 1079, + "statement_ns": 331118, + "success": true + }, + { + "mutex_wait_ns": 265856, + "serialization_ns": 54742, + "serialized_bytes": 1302, + "statement_ns": 388615, + "success": true + }, + { + "mutex_wait_ns": 349932, + "serialization_ns": 49923, + "serialized_bytes": 1087, + "statement_ns": 352608, + "success": true + }, + { + "mutex_wait_ns": 230, + "serialization_ns": 57878, + "serialized_bytes": 1302, + "statement_ns": 354862, + "success": true + }, + { + "mutex_wait_ns": 197338, + "serialization_ns": 27201, + "serialized_bytes": 613, + "statement_ns": 443507, + "success": true + }, + { + "mutex_wait_ns": 180, + "serialization_ns": 27592, + "serialized_bytes": 613, + "statement_ns": 343811, + "success": true + }, + { + "mutex_wait_ns": 171, + "serialization_ns": 52007, + "serialized_bytes": 1040, + "statement_ns": 384667, + "success": true + }, + { + "mutex_wait_ns": 241, + "serialization_ns": 46266, + "serialized_bytes": 1079, + "statement_ns": 537031, + "success": true + }, + { + "mutex_wait_ns": 150, + "serialization_ns": 47429, + "serialized_bytes": 1087, + "statement_ns": 406128, + "success": true + }, + { + "mutex_wait_ns": 220, + "serialization_ns": 55023, + "serialized_bytes": 1302, + "statement_ns": 475507, + "success": true + }, + { + "mutex_wait_ns": 391, + "serialization_ns": 47899, + "serialized_bytes": 613, + "statement_ns": 430232, + "success": true + }, + { + "mutex_wait_ns": 170, + "serialization_ns": 27852, + "serialized_bytes": 613, + "statement_ns": 340005, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 43432, + "serialized_bytes": 1040, + "statement_ns": 461722, + "success": true + }, + { + "mutex_wait_ns": 361, + "serialization_ns": 47969, + "serialized_bytes": 1079, + "statement_ns": 354682, + "success": true + }, + { + "mutex_wait_ns": 190, + "serialization_ns": 46637, + "serialized_bytes": 1087, + "statement_ns": 366393, + "success": true + }, + { + "mutex_wait_ns": 230, + "serialization_ns": 53951, + "serialized_bytes": 1302, + "statement_ns": 327671, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 1905003, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=1", + "COMPILER=gcc-11.4.0", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_PTHREADS", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "TLS", + "wall_budget_exceeded": false + } + ], + "not_run": { + "disk_flush_count": "not observed", + "gui_android": "outside harness", + "production_performance": "synthetic test-only harness", + "queue_wait": "no writer queue exists", + "sqlite_busy_wait_separate": "included in statement elapsed" + }, + "profile": "debug", + "runtime": "multi_thread", + "schema": 1, + "status": "PASS", + "timer_network_positive_control": { + "reason": "intentional blocking control requires current-thread runtime", + "status": "NOTRUN" + }, + "workers": 2 + }, + "cleanup_uncertain": false + }, + { + "profile": "release", + "workers": 0, + "status": "PASS", + "reason": null, + "report": { + "cases": [ + { + "batch_elapsed_ns": 82818771, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 82600062, + 82473847, + 82403626, + 82338996, + 82271680, + 82208603, + 82142239, + 82081836, + 82003781, + 81943548, + 81877886, + 81814698, + 81747783, + 81667394, + 81595399, + 81532362, + 81469865, + 81404723, + 81336696, + 81273989, + 81208847, + 81136704, + 81069959, + 81009116, + 80943523, + 80881868, + 80817979, + 80740314, + 80657460, + 80596226, + 80519933, + 80454371 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 74382537, + 164908, + 135643 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 74382537, + "end_ns": 84727283, + "in_window": true, + "scheduled_ns": null, + "start_ns": 10344746, + "success": true + }, + { + "elapsed_ns": 164908, + "end_ns": 94966560, + "in_window": false, + "scheduled_ns": null, + "start_ns": 94801652, + "success": true + }, + { + "elapsed_ns": 135643, + "end_ns": 105173116, + "in_window": false, + "scheduled_ns": null, + "start_ns": 105037473, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 72614098, + 901535, + 671566, + 1034994 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 7, + "samples": [ + { + "elapsed_ns": 72614098, + "end_ns": 84963420, + "in_window": true, + "scheduled_ns": 12349322, + "start_ns": 84963420, + "success": true + }, + { + "elapsed_ns": 901535, + "end_ns": 93250857, + "in_window": false, + "scheduled_ns": 92349322, + "start_ns": 93250857, + "success": true + }, + { + "elapsed_ns": 671566, + "end_ns": 103020888, + "in_window": false, + "scheduled_ns": 102349322, + "start_ns": 103020888, + "success": true + }, + { + "elapsed_ns": 1034994, + "end_ns": 113384316, + "in_window": false, + "scheduled_ns": 112349322, + "start_ns": 113384316, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 85172711, + "window_start_ns": 2353940 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 0, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 51, + "serialization_ns": 2545, + "serialized_bytes": 612, + "statement_ns": 600019, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2615, + "serialized_bytes": 612, + "statement_ns": 380710, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3917, + "serialized_bytes": 1038, + "statement_ns": 356275, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3516, + "serialized_bytes": 1077, + "statement_ns": 371883, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3577, + "serialized_bytes": 1085, + "statement_ns": 384296, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4268, + "serialized_bytes": 1300, + "statement_ns": 357547, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2314, + "serialized_bytes": 610, + "statement_ns": 496386, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2514, + "serialized_bytes": 610, + "statement_ns": 354031, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3367, + "serialized_bytes": 1034, + "statement_ns": 360223, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3446, + "serialized_bytes": 1073, + "statement_ns": 391760, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3787, + "serialized_bytes": 1081, + "statement_ns": 326799, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 4279, + "serialized_bytes": 1296, + "statement_ns": 373637, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2214, + "serialized_bytes": 612, + "statement_ns": 383285, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2485, + "serialized_bytes": 612, + "statement_ns": 320327, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3156, + "serialized_bytes": 1038, + "statement_ns": 432296, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3968, + "serialized_bytes": 1077, + "statement_ns": 369138, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3707, + "serialized_bytes": 1085, + "statement_ns": 415675, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3907, + "serialized_bytes": 1300, + "statement_ns": 400427, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2004, + "serialized_bytes": 612, + "statement_ns": 386922, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2314, + "serialized_bytes": 612, + "statement_ns": 360162, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3086, + "serialized_bytes": 1038, + "statement_ns": 454878, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3507, + "serialized_bytes": 1077, + "statement_ns": 364440, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3667, + "serialized_bytes": 1085, + "statement_ns": 330136, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3727, + "serialized_bytes": 1300, + "statement_ns": 333432, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1974, + "serialized_bytes": 612, + "statement_ns": 429150, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2304, + "serialized_bytes": 612, + "statement_ns": 412730, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3055, + "serialized_bytes": 1038, + "statement_ns": 370500, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3387, + "serialized_bytes": 1077, + "statement_ns": 344192, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3436, + "serialized_bytes": 1085, + "statement_ns": 413732, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3637, + "serialized_bytes": 1300, + "statement_ns": 410175, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1904, + "serialized_bytes": 612, + "statement_ns": 406107, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2305, + "serialized_bytes": 612, + "statement_ns": 367685, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3035, + "serialized_bytes": 1038, + "statement_ns": 375901, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3306, + "serialized_bytes": 1077, + "statement_ns": 358678, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3767, + "serialized_bytes": 1085, + "statement_ns": 420214, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3927, + "serialized_bytes": 1300, + "statement_ns": 469686, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 7854, + "serialized_bytes": 612, + "statement_ns": 2699194, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2375, + "serialized_bytes": 612, + "statement_ns": 389597, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3066, + "serialized_bytes": 1038, + "statement_ns": 496396, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3376, + "serialized_bytes": 1077, + "statement_ns": 428720, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3436, + "serialized_bytes": 1085, + "statement_ns": 387152, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3918, + "serialized_bytes": 1300, + "statement_ns": 542943, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1954, + "serialized_bytes": 610, + "statement_ns": 425714, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2314, + "serialized_bytes": 610, + "statement_ns": 330707, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3156, + "serialized_bytes": 1034, + "statement_ns": 361915, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3487, + "serialized_bytes": 1073, + "statement_ns": 342850, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3427, + "serialized_bytes": 1081, + "statement_ns": 342418, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3607, + "serialized_bytes": 1296, + "statement_ns": 416026, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1904, + "serialized_bytes": 612, + "statement_ns": 353109, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2214, + "serialized_bytes": 612, + "statement_ns": 335155, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2956, + "serialized_bytes": 1038, + "statement_ns": 376502, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3437, + "serialized_bytes": 1077, + "statement_ns": 445781, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3466, + "serialized_bytes": 1085, + "statement_ns": 351545, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3957, + "serialized_bytes": 1300, + "statement_ns": 437717, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1933, + "serialized_bytes": 610, + "statement_ns": 341367, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 21590, + "serialized_bytes": 610, + "statement_ns": 379198, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3036, + "serialized_bytes": 1034, + "statement_ns": 353149, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3217, + "serialized_bytes": 1073, + "statement_ns": 368286, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4569, + "serialized_bytes": 1081, + "statement_ns": 396329, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3647, + "serialized_bytes": 1296, + "statement_ns": 331688, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2254, + "serialized_bytes": 610, + "statement_ns": 526663, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 2244, + "serialized_bytes": 610, + "statement_ns": 368437, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2945, + "serialized_bytes": 1034, + "statement_ns": 363308, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3356, + "serialized_bytes": 1073, + "statement_ns": 322972, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3197, + "serialized_bytes": 1081, + "statement_ns": 305120, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3506, + "serialized_bytes": 1296, + "statement_ns": 372234, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2054, + "serialized_bytes": 612, + "statement_ns": 465177, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2234, + "serialized_bytes": 612, + "statement_ns": 313475, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3146, + "serialized_bytes": 1038, + "statement_ns": 409954, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3206, + "serialized_bytes": 1077, + "statement_ns": 411797, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3467, + "serialized_bytes": 1085, + "statement_ns": 444589, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3737, + "serialized_bytes": 1300, + "statement_ns": 368237, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 1993, + "serialized_bytes": 610, + "statement_ns": 418761, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2304, + "serialized_bytes": 610, + "statement_ns": 397552, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3156, + "serialized_bytes": 1034, + "statement_ns": 324375, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3236, + "serialized_bytes": 1073, + "statement_ns": 383115, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3686, + "serialized_bytes": 1081, + "statement_ns": 319246, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3567, + "serialized_bytes": 1296, + "statement_ns": 375109, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2284, + "serialized_bytes": 610, + "statement_ns": 387923, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2384, + "serialized_bytes": 610, + "statement_ns": 414483, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3146, + "serialized_bytes": 1034, + "statement_ns": 387754, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3357, + "serialized_bytes": 1073, + "statement_ns": 347227, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3427, + "serialized_bytes": 1081, + "statement_ns": 399695, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3617, + "serialized_bytes": 1296, + "statement_ns": 356525, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 2014, + "serialized_bytes": 612, + "statement_ns": 379327, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2274, + "serialized_bytes": 612, + "statement_ns": 340094, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3778, + "serialized_bytes": 1038, + "statement_ns": 343410, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3687, + "serialized_bytes": 1077, + "statement_ns": 389807, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 5831, + "serialized_bytes": 1085, + "statement_ns": 366353, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3707, + "serialized_bytes": 1300, + "statement_ns": 415254, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1974, + "serialized_bytes": 612, + "statement_ns": 394446, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 2434, + "serialized_bytes": 612, + "statement_ns": 345223, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3016, + "serialized_bytes": 1038, + "statement_ns": 333933, + "success": true + }, + { + "mutex_wait_ns": 60, + "serialization_ns": 5410, + "serialized_bytes": 1077, + "statement_ns": 323013, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3527, + "serialized_bytes": 1085, + "statement_ns": 362135, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3416, + "serialized_bytes": 1300, + "statement_ns": 332530, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1934, + "serialized_bytes": 612, + "statement_ns": 338752, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2405, + "serialized_bytes": 612, + "statement_ns": 296543, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3076, + "serialized_bytes": 1038, + "statement_ns": 315138, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3346, + "serialized_bytes": 1077, + "statement_ns": 302414, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3666, + "serialized_bytes": 1085, + "statement_ns": 338552, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3557, + "serialized_bytes": 1300, + "statement_ns": 371833, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2014, + "serialized_bytes": 610, + "statement_ns": 391019, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2295, + "serialized_bytes": 610, + "statement_ns": 290341, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3096, + "serialized_bytes": 1034, + "statement_ns": 307784, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3537, + "serialized_bytes": 1073, + "statement_ns": 398012, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3416, + "serialized_bytes": 1081, + "statement_ns": 330486, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3477, + "serialized_bytes": 1296, + "statement_ns": 356686, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1944, + "serialized_bytes": 610, + "statement_ns": 482500, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2315, + "serialized_bytes": 610, + "statement_ns": 1316675, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3036, + "serialized_bytes": 1034, + "statement_ns": 379207, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3136, + "serialized_bytes": 1073, + "statement_ns": 319837, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3406, + "serialized_bytes": 1081, + "statement_ns": 441804, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3587, + "serialized_bytes": 1296, + "statement_ns": 921238, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2014, + "serialized_bytes": 612, + "statement_ns": 436424, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2464, + "serialized_bytes": 612, + "statement_ns": 361254, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3036, + "serialized_bytes": 1038, + "statement_ns": 398503, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3416, + "serialized_bytes": 1077, + "statement_ns": 369820, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3436, + "serialized_bytes": 1085, + "statement_ns": 449890, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3777, + "serialized_bytes": 1300, + "statement_ns": 347097, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2665, + "serialized_bytes": 612, + "statement_ns": 411898, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2484, + "serialized_bytes": 612, + "statement_ns": 360171, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2966, + "serialized_bytes": 1038, + "statement_ns": 457804, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3236, + "serialized_bytes": 1077, + "statement_ns": 383525, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3336, + "serialized_bytes": 1085, + "statement_ns": 392873, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3717, + "serialized_bytes": 1300, + "statement_ns": 419813, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2043, + "serialized_bytes": 612, + "statement_ns": 403212, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2314, + "serialized_bytes": 612, + "statement_ns": 352257, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3096, + "serialized_bytes": 1038, + "statement_ns": 329144, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3106, + "serialized_bytes": 1077, + "statement_ns": 352297, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3417, + "serialized_bytes": 1085, + "statement_ns": 334634, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3406, + "serialized_bytes": 1300, + "statement_ns": 328232, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2033, + "serialized_bytes": 610, + "statement_ns": 330045, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 2294, + "serialized_bytes": 610, + "statement_ns": 326659, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3136, + "serialized_bytes": 1034, + "statement_ns": 310179, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3317, + "serialized_bytes": 1073, + "statement_ns": 304447, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3417, + "serialized_bytes": 1081, + "statement_ns": 332420, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3366, + "serialized_bytes": 1296, + "statement_ns": 337038, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2024, + "serialized_bytes": 612, + "statement_ns": 403573, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2354, + "serialized_bytes": 612, + "statement_ns": 301192, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3006, + "serialized_bytes": 1038, + "statement_ns": 328983, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3146, + "serialized_bytes": 1077, + "statement_ns": 320788, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5640, + "serialized_bytes": 1085, + "statement_ns": 319246, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3336, + "serialized_bytes": 1300, + "statement_ns": 309528, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1903, + "serialized_bytes": 612, + "statement_ns": 343330, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2514, + "serialized_bytes": 612, + "statement_ns": 316831, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3427, + "serialized_bytes": 1038, + "statement_ns": 525019, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3426, + "serialized_bytes": 1077, + "statement_ns": 422759, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3516, + "serialized_bytes": 1085, + "statement_ns": 374469, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3456, + "serialized_bytes": 1300, + "statement_ns": 378917, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 1994, + "serialized_bytes": 612, + "statement_ns": 358268, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2234, + "serialized_bytes": 612, + "statement_ns": 296914, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2856, + "serialized_bytes": 1038, + "statement_ns": 388284, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3216, + "serialized_bytes": 1077, + "statement_ns": 331639, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3197, + "serialized_bytes": 1085, + "statement_ns": 389427, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3246, + "serialized_bytes": 1300, + "statement_ns": 367806, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 1994, + "serialized_bytes": 610, + "statement_ns": 377815, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 2205, + "serialized_bytes": 610, + "statement_ns": 317643, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3015, + "serialized_bytes": 1034, + "statement_ns": 444570, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3136, + "serialized_bytes": 1073, + "statement_ns": 313514, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3357, + "serialized_bytes": 1081, + "statement_ns": 356374, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3346, + "serialized_bytes": 1296, + "statement_ns": 331959, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 2785, + "serialized_bytes": 612, + "statement_ns": 359530, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2415, + "serialized_bytes": 612, + "statement_ns": 338181, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3036, + "serialized_bytes": 1038, + "statement_ns": 305560, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3466, + "serialized_bytes": 1077, + "statement_ns": 319065, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3717, + "serialized_bytes": 1085, + "statement_ns": 303366, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3507, + "serialized_bytes": 1300, + "statement_ns": 307033, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2023, + "serialized_bytes": 612, + "statement_ns": 353310, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2445, + "serialized_bytes": 612, + "statement_ns": 302133, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3316, + "serialized_bytes": 1038, + "statement_ns": 307774, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3016, + "serialized_bytes": 1077, + "statement_ns": 317101, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3346, + "serialized_bytes": 1085, + "statement_ns": 341266, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3546, + "serialized_bytes": 1300, + "statement_ns": 338371, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1864, + "serialized_bytes": 612, + "statement_ns": 337700, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2284, + "serialized_bytes": 612, + "statement_ns": 291493, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2926, + "serialized_bytes": 1038, + "statement_ns": 301372, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3357, + "serialized_bytes": 1077, + "statement_ns": 328011, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3476, + "serialized_bytes": 1085, + "statement_ns": 306843, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3306, + "serialized_bytes": 1300, + "statement_ns": 320999, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1833, + "serialized_bytes": 612, + "statement_ns": 339223, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2244, + "serialized_bytes": 612, + "statement_ns": 289209, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2946, + "serialized_bytes": 1038, + "statement_ns": 300931, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3246, + "serialized_bytes": 1077, + "statement_ns": 370871, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3507, + "serialized_bytes": 1085, + "statement_ns": 320127, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3436, + "serialized_bytes": 1300, + "statement_ns": 339083, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1994, + "serialized_bytes": 612, + "statement_ns": 364750, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 2304, + "serialized_bytes": 612, + "statement_ns": 285562, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2795, + "serialized_bytes": 1038, + "statement_ns": 304899, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3036, + "serialized_bytes": 1077, + "statement_ns": 403543, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3397, + "serialized_bytes": 1085, + "statement_ns": 481598, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3367, + "serialized_bytes": 1300, + "statement_ns": 378326, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 1003602, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=1", + "COMPILER=gcc-11.4.0", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_PTHREADS", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "HTTP", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 74937562, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 74754560, + 74676034, + 74629959, + 74586286, + 74544559, + 74501228, + 74458739, + 74419085, + 74378649, + 74336712, + 74271650, + 74224902, + 74181973, + 74140095, + 74098628, + 74058291, + 74017847, + 73977581, + 73936645, + 73894917, + 73852468, + 73811141, + 73769703, + 73729048, + 73686989, + 73637898, + 73596231, + 73559452, + 73517313, + 73467710, + 73410163, + 73334562 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 65468301, + 164176, + 150721 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 65468301, + "end_ns": 76666312, + "in_window": true, + "scheduled_ns": null, + "start_ns": 11198011, + "success": true + }, + { + "elapsed_ns": 164176, + "end_ns": 86905619, + "in_window": false, + "scheduled_ns": null, + "start_ns": 86741443, + "success": true + }, + { + "elapsed_ns": 150721, + "end_ns": 97128666, + "in_window": false, + "scheduled_ns": null, + "start_ns": 96977945, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 64746135, + 1014646, + 775801, + 1076532 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 6, + "samples": [ + { + "elapsed_ns": 64746135, + "end_ns": 76927884, + "in_window": true, + "scheduled_ns": 12181749, + "start_ns": 76927884, + "success": true + }, + { + "elapsed_ns": 1014646, + "end_ns": 83196395, + "in_window": false, + "scheduled_ns": 82181749, + "start_ns": 83196395, + "success": true + }, + { + "elapsed_ns": 775801, + "end_ns": 92957550, + "in_window": false, + "scheduled_ns": 92181749, + "start_ns": 92957550, + "success": true + }, + { + "elapsed_ns": 1076532, + "end_ns": 103258281, + "in_window": false, + "scheduled_ns": 102181749, + "start_ns": 103258281, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 77123789, + "window_start_ns": 2186227 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 1, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 40, + "serialization_ns": 2846, + "serialized_bytes": 612, + "statement_ns": 459777, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2634, + "serialized_bytes": 612, + "statement_ns": 327221, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3817, + "serialized_bytes": 1038, + "statement_ns": 360482, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4128, + "serialized_bytes": 1077, + "statement_ns": 349672, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3827, + "serialized_bytes": 1085, + "statement_ns": 343892, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4078, + "serialized_bytes": 1300, + "statement_ns": 308836, + "success": true + }, + { + "mutex_wait_ns": 51, + "serialization_ns": 2124, + "serialized_bytes": 610, + "statement_ns": 330245, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2334, + "serialized_bytes": 610, + "statement_ns": 322832, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3727, + "serialized_bytes": 1034, + "statement_ns": 321530, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3576, + "serialized_bytes": 1073, + "statement_ns": 352918, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3757, + "serialized_bytes": 1081, + "statement_ns": 307283, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3927, + "serialized_bytes": 1296, + "statement_ns": 289439, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2094, + "serialized_bytes": 610, + "statement_ns": 354271, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2425, + "serialized_bytes": 610, + "statement_ns": 310779, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3416, + "serialized_bytes": 1034, + "statement_ns": 313554, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3596, + "serialized_bytes": 1073, + "statement_ns": 339974, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3437, + "serialized_bytes": 1081, + "statement_ns": 409503, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4098, + "serialized_bytes": 1296, + "statement_ns": 441493, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2014, + "serialized_bytes": 612, + "statement_ns": 475897, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2564, + "serialized_bytes": 612, + "statement_ns": 386221, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3717, + "serialized_bytes": 1038, + "statement_ns": 342850, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3566, + "serialized_bytes": 1077, + "statement_ns": 345674, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3637, + "serialized_bytes": 1085, + "statement_ns": 303286, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3928, + "serialized_bytes": 1300, + "statement_ns": 333542, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1974, + "serialized_bytes": 612, + "statement_ns": 340675, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2484, + "serialized_bytes": 612, + "statement_ns": 276144, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3276, + "serialized_bytes": 1038, + "statement_ns": 885171, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3696, + "serialized_bytes": 1077, + "statement_ns": 401038, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3647, + "serialized_bytes": 1085, + "statement_ns": 354361, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3918, + "serialized_bytes": 1300, + "statement_ns": 352277, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 1873, + "serialized_bytes": 610, + "statement_ns": 371703, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2465, + "serialized_bytes": 610, + "statement_ns": 551008, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3637, + "serialized_bytes": 1034, + "statement_ns": 426896, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3547, + "serialized_bytes": 1073, + "statement_ns": 352197, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3606, + "serialized_bytes": 1081, + "statement_ns": 338832, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3958, + "serialized_bytes": 1296, + "statement_ns": 363959, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2394, + "serialized_bytes": 610, + "statement_ns": 340676, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2484, + "serialized_bytes": 610, + "statement_ns": 295250, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3426, + "serialized_bytes": 1034, + "statement_ns": 346536, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3808, + "serialized_bytes": 1073, + "statement_ns": 351910, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 5631, + "serialized_bytes": 1081, + "statement_ns": 348561, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4298, + "serialized_bytes": 1296, + "statement_ns": 347929, + "success": true + }, + { + "mutex_wait_ns": 49, + "serialization_ns": 2445, + "serialized_bytes": 612, + "statement_ns": 362427, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2665, + "serialized_bytes": 612, + "statement_ns": 379828, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3887, + "serialized_bytes": 1038, + "statement_ns": 329424, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4328, + "serialized_bytes": 1077, + "statement_ns": 409424, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4088, + "serialized_bytes": 1085, + "statement_ns": 391841, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4057, + "serialized_bytes": 1300, + "statement_ns": 359902, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2094, + "serialized_bytes": 612, + "statement_ns": 413521, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2585, + "serialized_bytes": 612, + "statement_ns": 291112, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3527, + "serialized_bytes": 1038, + "statement_ns": 303757, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3687, + "serialized_bytes": 1077, + "statement_ns": 312473, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3867, + "serialized_bytes": 1085, + "statement_ns": 390799, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3797, + "serialized_bytes": 1300, + "statement_ns": 438879, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1984, + "serialized_bytes": 612, + "statement_ns": 366353, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2385, + "serialized_bytes": 612, + "statement_ns": 338611, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3446, + "serialized_bytes": 1038, + "statement_ns": 881875, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3897, + "serialized_bytes": 1077, + "statement_ns": 382093, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3767, + "serialized_bytes": 1085, + "statement_ns": 362346, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4048, + "serialized_bytes": 1300, + "statement_ns": 349953, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1903, + "serialized_bytes": 612, + "statement_ns": 379728, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2424, + "serialized_bytes": 612, + "statement_ns": 377204, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3457, + "serialized_bytes": 1038, + "statement_ns": 315037, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3626, + "serialized_bytes": 1077, + "statement_ns": 369018, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3807, + "serialized_bytes": 1085, + "statement_ns": 337400, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3807, + "serialized_bytes": 1300, + "statement_ns": 374699, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2034, + "serialized_bytes": 610, + "statement_ns": 330747, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2445, + "serialized_bytes": 610, + "statement_ns": 301933, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3276, + "serialized_bytes": 1034, + "statement_ns": 343250, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3547, + "serialized_bytes": 1073, + "statement_ns": 350463, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3797, + "serialized_bytes": 1081, + "statement_ns": 328343, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3747, + "serialized_bytes": 1296, + "statement_ns": 372375, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 1994, + "serialized_bytes": 610, + "statement_ns": 350073, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 2304, + "serialized_bytes": 610, + "statement_ns": 340855, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3197, + "serialized_bytes": 1034, + "statement_ns": 354200, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3557, + "serialized_bytes": 1073, + "statement_ns": 310118, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3737, + "serialized_bytes": 1081, + "statement_ns": 313584, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3727, + "serialized_bytes": 1296, + "statement_ns": 376823, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2665, + "serialized_bytes": 610, + "statement_ns": 323584, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2244, + "serialized_bytes": 610, + "statement_ns": 321440, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3146, + "serialized_bytes": 1034, + "statement_ns": 336217, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3246, + "serialized_bytes": 1073, + "statement_ns": 287616, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3486, + "serialized_bytes": 1081, + "statement_ns": 286294, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3687, + "serialized_bytes": 1296, + "statement_ns": 352197, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2074, + "serialized_bytes": 610, + "statement_ns": 316871, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2384, + "serialized_bytes": 610, + "statement_ns": 278379, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3166, + "serialized_bytes": 1034, + "statement_ns": 333954, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3607, + "serialized_bytes": 1073, + "statement_ns": 290131, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3607, + "serialized_bytes": 1081, + "statement_ns": 287106, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3587, + "serialized_bytes": 1296, + "statement_ns": 387142, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1984, + "serialized_bytes": 612, + "statement_ns": 646305, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3587, + "serialized_bytes": 612, + "statement_ns": 355292, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3356, + "serialized_bytes": 1038, + "statement_ns": 321760, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3667, + "serialized_bytes": 1077, + "statement_ns": 354571, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3687, + "serialized_bytes": 1085, + "statement_ns": 360803, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3556, + "serialized_bytes": 1300, + "statement_ns": 327221, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1993, + "serialized_bytes": 612, + "statement_ns": 587226, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2635, + "serialized_bytes": 612, + "statement_ns": 290783, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3025, + "serialized_bytes": 1038, + "statement_ns": 521313, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3336, + "serialized_bytes": 1077, + "statement_ns": 365793, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3596, + "serialized_bytes": 1085, + "statement_ns": 326629, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3456, + "serialized_bytes": 1300, + "statement_ns": 385790, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1993, + "serialized_bytes": 612, + "statement_ns": 329445, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2354, + "serialized_bytes": 612, + "statement_ns": 317202, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3156, + "serialized_bytes": 1038, + "statement_ns": 365381, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3587, + "serialized_bytes": 1077, + "statement_ns": 360903, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3877, + "serialized_bytes": 1085, + "statement_ns": 354682, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3817, + "serialized_bytes": 1300, + "statement_ns": 447755, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 1844, + "serialized_bytes": 612, + "statement_ns": 379388, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2334, + "serialized_bytes": 612, + "statement_ns": 286805, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3196, + "serialized_bytes": 1038, + "statement_ns": 285633, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3477, + "serialized_bytes": 1077, + "statement_ns": 289209, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3557, + "serialized_bytes": 1085, + "statement_ns": 370180, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3557, + "serialized_bytes": 1300, + "statement_ns": 355563, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1823, + "serialized_bytes": 612, + "statement_ns": 392913, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2304, + "serialized_bytes": 612, + "statement_ns": 307173, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3076, + "serialized_bytes": 1038, + "statement_ns": 313805, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3396, + "serialized_bytes": 1077, + "statement_ns": 344292, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3697, + "serialized_bytes": 1085, + "statement_ns": 293998, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3587, + "serialized_bytes": 1300, + "statement_ns": 293728, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2805, + "serialized_bytes": 612, + "statement_ns": 362055, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2334, + "serialized_bytes": 612, + "statement_ns": 293297, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3186, + "serialized_bytes": 1038, + "statement_ns": 291984, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3707, + "serialized_bytes": 1077, + "statement_ns": 369418, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3707, + "serialized_bytes": 1085, + "statement_ns": 378226, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3557, + "serialized_bytes": 1300, + "statement_ns": 372053, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1814, + "serialized_bytes": 612, + "statement_ns": 420113, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 2525, + "serialized_bytes": 612, + "statement_ns": 311702, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2945, + "serialized_bytes": 1038, + "statement_ns": 336788, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3778, + "serialized_bytes": 1077, + "statement_ns": 323804, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3747, + "serialized_bytes": 1085, + "statement_ns": 291473, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3697, + "serialized_bytes": 1300, + "statement_ns": 283168, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2164, + "serialized_bytes": 612, + "statement_ns": 353609, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 2685, + "serialized_bytes": 612, + "statement_ns": 340726, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3226, + "serialized_bytes": 1038, + "statement_ns": 341387, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3386, + "serialized_bytes": 1077, + "statement_ns": 329885, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3587, + "serialized_bytes": 1085, + "statement_ns": 306842, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3566, + "serialized_bytes": 1300, + "statement_ns": 449669, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2124, + "serialized_bytes": 610, + "statement_ns": 388475, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2595, + "serialized_bytes": 610, + "statement_ns": 432236, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3135, + "serialized_bytes": 1034, + "statement_ns": 320849, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3306, + "serialized_bytes": 1073, + "statement_ns": 316540, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3476, + "serialized_bytes": 1081, + "statement_ns": 400387, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3657, + "serialized_bytes": 1296, + "statement_ns": 391049, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 2414, + "serialized_bytes": 612, + "statement_ns": 329915, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2324, + "serialized_bytes": 612, + "statement_ns": 335075, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3146, + "serialized_bytes": 1038, + "statement_ns": 308856, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3346, + "serialized_bytes": 1077, + "statement_ns": 299589, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3406, + "serialized_bytes": 1085, + "statement_ns": 325256, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3617, + "serialized_bytes": 1300, + "statement_ns": 377263, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1884, + "serialized_bytes": 612, + "statement_ns": 362375, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2405, + "serialized_bytes": 612, + "statement_ns": 285082, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3056, + "serialized_bytes": 1038, + "statement_ns": 330196, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3537, + "serialized_bytes": 1077, + "statement_ns": 294529, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3597, + "serialized_bytes": 1085, + "statement_ns": 334204, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3677, + "serialized_bytes": 1300, + "statement_ns": 341697, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1924, + "serialized_bytes": 612, + "statement_ns": 384517, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2385, + "serialized_bytes": 612, + "statement_ns": 338832, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3005, + "serialized_bytes": 1038, + "statement_ns": 302143, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3146, + "serialized_bytes": 1077, + "statement_ns": 312162, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3497, + "serialized_bytes": 1085, + "statement_ns": 360803, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3486, + "serialized_bytes": 1300, + "statement_ns": 370351, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 1773, + "serialized_bytes": 612, + "statement_ns": 411995, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2745, + "serialized_bytes": 612, + "statement_ns": 348900, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3457, + "serialized_bytes": 1038, + "statement_ns": 364179, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3837, + "serialized_bytes": 1077, + "statement_ns": 351957, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3637, + "serialized_bytes": 1085, + "statement_ns": 321990, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3828, + "serialized_bytes": 1300, + "statement_ns": 320517, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2264, + "serialized_bytes": 610, + "statement_ns": 354552, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2305, + "serialized_bytes": 610, + "statement_ns": 290882, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2946, + "serialized_bytes": 1034, + "statement_ns": 386852, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3366, + "serialized_bytes": 1073, + "statement_ns": 331839, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3376, + "serialized_bytes": 1081, + "statement_ns": 313695, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3777, + "serialized_bytes": 1296, + "statement_ns": 369690, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 1984, + "serialized_bytes": 612, + "statement_ns": 327330, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2254, + "serialized_bytes": 612, + "statement_ns": 311972, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3066, + "serialized_bytes": 1038, + "statement_ns": 363108, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3406, + "serialized_bytes": 1077, + "statement_ns": 292576, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3426, + "serialized_bytes": 1085, + "statement_ns": 308556, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3476, + "serialized_bytes": 1300, + "statement_ns": 350133, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1913, + "serialized_bytes": 612, + "statement_ns": 319967, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2474, + "serialized_bytes": 612, + "statement_ns": 285303, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2816, + "serialized_bytes": 1038, + "statement_ns": 333973, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3126, + "serialized_bytes": 1077, + "statement_ns": 290653, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3306, + "serialized_bytes": 1085, + "statement_ns": 291504, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3487, + "serialized_bytes": 1300, + "statement_ns": 458155, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 1873, + "serialized_bytes": 612, + "statement_ns": 520000, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2144, + "serialized_bytes": 612, + "statement_ns": 471570, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3156, + "serialized_bytes": 1038, + "statement_ns": 329675, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3526, + "serialized_bytes": 1077, + "statement_ns": 328483, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3556, + "serialized_bytes": 1085, + "statement_ns": 335796, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3427, + "serialized_bytes": 1300, + "statement_ns": 337850, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 1046612, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=1", + "COMPILER=gcc-11.4.0", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_PTHREADS", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "HTTP", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 69674566, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 69492587, + 69387320, + 69335935, + 69287404, + 69244404, + 69196574, + 69152343, + 69113349, + 69073254, + 69031126, + 68988957, + 68947059, + 68904720, + 68864155, + 68822537, + 68779968, + 68740233, + 68699498, + 68657910, + 68615130, + 68574163, + 68531804, + 68461083, + 68415818, + 68373820, + 68331371, + 68290104, + 68258706, + 68216096, + 68174959, + 68122280, + 68078820 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 60261260, + 163465, + 139390 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 60261260, + "end_ns": 71282452, + "in_window": true, + "scheduled_ns": null, + "start_ns": 11021192, + "success": true + }, + { + "elapsed_ns": 163465, + "end_ns": 81518612, + "in_window": false, + "scheduled_ns": null, + "start_ns": 81355147, + "success": true + }, + { + "elapsed_ns": 139390, + "end_ns": 91729046, + "in_window": false, + "scheduled_ns": null, + "start_ns": 91589656, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 59488499, + 748379, + 575347, + 790869 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 5, + "samples": [ + { + "elapsed_ns": 59488499, + "end_ns": 71496003, + "in_window": true, + "scheduled_ns": 12007504, + "start_ns": 71496003, + "success": true + }, + { + "elapsed_ns": 748379, + "end_ns": 72755883, + "in_window": false, + "scheduled_ns": 72007504, + "start_ns": 72755883, + "success": true + }, + { + "elapsed_ns": 575347, + "end_ns": 82582851, + "in_window": false, + "scheduled_ns": 82007504, + "start_ns": 82582851, + "success": true + }, + { + "elapsed_ns": 790869, + "end_ns": 92798373, + "in_window": false, + "scheduled_ns": 92007504, + "start_ns": 92798373, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 71686449, + "window_start_ns": 2011883 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 2, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 50, + "serialization_ns": 2755, + "serialized_bytes": 612, + "statement_ns": 443728, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2695, + "serialized_bytes": 612, + "statement_ns": 319005, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3877, + "serialized_bytes": 1038, + "statement_ns": 306021, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 4037, + "serialized_bytes": 1077, + "statement_ns": 326298, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4508, + "serialized_bytes": 1085, + "statement_ns": 348611, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3667, + "serialized_bytes": 1300, + "statement_ns": 307874, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2284, + "serialized_bytes": 610, + "statement_ns": 341127, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2495, + "serialized_bytes": 610, + "statement_ns": 289139, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3547, + "serialized_bytes": 1034, + "statement_ns": 289059, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3427, + "serialized_bytes": 1073, + "statement_ns": 327792, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3857, + "serialized_bytes": 1081, + "statement_ns": 358589, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3467, + "serialized_bytes": 1296, + "statement_ns": 299138, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2034, + "serialized_bytes": 612, + "statement_ns": 408482, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2535, + "serialized_bytes": 612, + "statement_ns": 321109, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3366, + "serialized_bytes": 1038, + "statement_ns": 314466, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3737, + "serialized_bytes": 1077, + "statement_ns": 330857, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3707, + "serialized_bytes": 1085, + "statement_ns": 295270, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3436, + "serialized_bytes": 1300, + "statement_ns": 314737, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2134, + "serialized_bytes": 612, + "statement_ns": 350885, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2365, + "serialized_bytes": 612, + "statement_ns": 350914, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3116, + "serialized_bytes": 1038, + "statement_ns": 351185, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3226, + "serialized_bytes": 1077, + "statement_ns": 375971, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3547, + "serialized_bytes": 1085, + "statement_ns": 287546, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3617, + "serialized_bytes": 1300, + "statement_ns": 541289, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1964, + "serialized_bytes": 612, + "statement_ns": 426105, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 2375, + "serialized_bytes": 612, + "statement_ns": 331208, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3055, + "serialized_bytes": 1038, + "statement_ns": 347167, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3536, + "serialized_bytes": 1077, + "statement_ns": 289349, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3406, + "serialized_bytes": 1085, + "statement_ns": 325868, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3277, + "serialized_bytes": 1300, + "statement_ns": 399996, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1824, + "serialized_bytes": 612, + "statement_ns": 359049, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2215, + "serialized_bytes": 612, + "statement_ns": 300240, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3215, + "serialized_bytes": 1038, + "statement_ns": 297003, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3136, + "serialized_bytes": 1077, + "statement_ns": 315679, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3506, + "serialized_bytes": 1085, + "statement_ns": 367596, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5300, + "serialized_bytes": 1300, + "statement_ns": 312343, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 2213, + "serialized_bytes": 610, + "statement_ns": 380279, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 2335, + "serialized_bytes": 610, + "statement_ns": 317623, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3416, + "serialized_bytes": 1034, + "statement_ns": 294459, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3516, + "serialized_bytes": 1073, + "statement_ns": 289500, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3918, + "serialized_bytes": 1081, + "statement_ns": 309527, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3897, + "serialized_bytes": 1296, + "statement_ns": 325366, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2094, + "serialized_bytes": 610, + "statement_ns": 301512, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2414, + "serialized_bytes": 610, + "statement_ns": 284812, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3267, + "serialized_bytes": 1034, + "statement_ns": 327101, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3486, + "serialized_bytes": 1073, + "statement_ns": 291674, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3537, + "serialized_bytes": 1081, + "statement_ns": 354171, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3386, + "serialized_bytes": 1296, + "statement_ns": 364119, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2113, + "serialized_bytes": 612, + "statement_ns": 343080, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2675, + "serialized_bytes": 612, + "statement_ns": 322061, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3125, + "serialized_bytes": 1038, + "statement_ns": 294679, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3426, + "serialized_bytes": 1077, + "statement_ns": 293056, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3417, + "serialized_bytes": 1085, + "statement_ns": 308045, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3787, + "serialized_bytes": 1300, + "statement_ns": 418461, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1894, + "serialized_bytes": 612, + "statement_ns": 314076, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2274, + "serialized_bytes": 612, + "statement_ns": 296343, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3206, + "serialized_bytes": 1038, + "statement_ns": 304508, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3587, + "serialized_bytes": 1077, + "statement_ns": 287647, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3446, + "serialized_bytes": 1085, + "statement_ns": 305650, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3296, + "serialized_bytes": 1300, + "statement_ns": 311621, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 1874, + "serialized_bytes": 612, + "statement_ns": 361223, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2334, + "serialized_bytes": 612, + "statement_ns": 327431, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3277, + "serialized_bytes": 1038, + "statement_ns": 343430, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3727, + "serialized_bytes": 1077, + "statement_ns": 361624, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3627, + "serialized_bytes": 1085, + "statement_ns": 355693, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3697, + "serialized_bytes": 1300, + "statement_ns": 385649, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1933, + "serialized_bytes": 612, + "statement_ns": 368808, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2585, + "serialized_bytes": 612, + "statement_ns": 432377, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3437, + "serialized_bytes": 1038, + "statement_ns": 585001, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3706, + "serialized_bytes": 1077, + "statement_ns": 454427, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3677, + "serialized_bytes": 1085, + "statement_ns": 371924, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3817, + "serialized_bytes": 1300, + "statement_ns": 370241, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 2104, + "serialized_bytes": 610, + "statement_ns": 368317, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2485, + "serialized_bytes": 610, + "statement_ns": 367004, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3477, + "serialized_bytes": 1034, + "statement_ns": 300911, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3536, + "serialized_bytes": 1073, + "statement_ns": 303986, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3647, + "serialized_bytes": 1081, + "statement_ns": 336017, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3597, + "serialized_bytes": 1296, + "statement_ns": 314627, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2344, + "serialized_bytes": 612, + "statement_ns": 302785, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2324, + "serialized_bytes": 612, + "statement_ns": 325286, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3086, + "serialized_bytes": 1038, + "statement_ns": 301933, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3286, + "serialized_bytes": 1077, + "statement_ns": 325467, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3617, + "serialized_bytes": 1085, + "statement_ns": 328743, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3837, + "serialized_bytes": 1300, + "statement_ns": 299158, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1964, + "serialized_bytes": 612, + "statement_ns": 331308, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2104, + "serialized_bytes": 612, + "statement_ns": 307734, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3356, + "serialized_bytes": 1038, + "statement_ns": 299729, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3296, + "serialized_bytes": 1077, + "statement_ns": 309428, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3557, + "serialized_bytes": 1085, + "statement_ns": 310790, + "success": true + }, + { + "mutex_wait_ns": 60, + "serialization_ns": 27411, + "serialized_bytes": 1300, + "statement_ns": 391200, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2054, + "serialized_bytes": 610, + "statement_ns": 332400, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2335, + "serialized_bytes": 610, + "statement_ns": 295050, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2996, + "serialized_bytes": 1034, + "statement_ns": 313584, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3065, + "serialized_bytes": 1073, + "statement_ns": 288989, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3416, + "serialized_bytes": 1081, + "statement_ns": 336096, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3407, + "serialized_bytes": 1296, + "statement_ns": 318273, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1833, + "serialized_bytes": 610, + "statement_ns": 317893, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2214, + "serialized_bytes": 610, + "statement_ns": 284390, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3095, + "serialized_bytes": 1034, + "statement_ns": 285483, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3436, + "serialized_bytes": 1073, + "statement_ns": 284591, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3547, + "serialized_bytes": 1081, + "statement_ns": 301262, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3497, + "serialized_bytes": 1296, + "statement_ns": 361524, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 1973, + "serialized_bytes": 610, + "statement_ns": 300761, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2174, + "serialized_bytes": 610, + "statement_ns": 279361, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2935, + "serialized_bytes": 1034, + "statement_ns": 357717, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3236, + "serialized_bytes": 1073, + "statement_ns": 289460, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3446, + "serialized_bytes": 1081, + "statement_ns": 289210, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3577, + "serialized_bytes": 1296, + "statement_ns": 290732, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2013, + "serialized_bytes": 612, + "statement_ns": 332611, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2314, + "serialized_bytes": 612, + "statement_ns": 303697, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3106, + "serialized_bytes": 1038, + "statement_ns": 292405, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3356, + "serialized_bytes": 1077, + "statement_ns": 283048, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3456, + "serialized_bytes": 1085, + "statement_ns": 290472, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3627, + "serialized_bytes": 1300, + "statement_ns": 480606, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1834, + "serialized_bytes": 612, + "statement_ns": 515471, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2235, + "serialized_bytes": 612, + "statement_ns": 638330, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3056, + "serialized_bytes": 1038, + "statement_ns": 372455, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3406, + "serialized_bytes": 1077, + "statement_ns": 317442, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3687, + "serialized_bytes": 1085, + "statement_ns": 299860, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3557, + "serialized_bytes": 1300, + "statement_ns": 293387, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 2455, + "serialized_bytes": 612, + "statement_ns": 325928, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2455, + "serialized_bytes": 612, + "statement_ns": 327130, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3116, + "serialized_bytes": 1038, + "statement_ns": 302594, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3206, + "serialized_bytes": 1077, + "statement_ns": 351756, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3457, + "serialized_bytes": 1085, + "statement_ns": 318003, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3737, + "serialized_bytes": 1300, + "statement_ns": 316831, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1813, + "serialized_bytes": 612, + "statement_ns": 331809, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2284, + "serialized_bytes": 612, + "statement_ns": 282236, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2875, + "serialized_bytes": 1038, + "statement_ns": 348610, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3195, + "serialized_bytes": 1077, + "statement_ns": 330195, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3616, + "serialized_bytes": 1085, + "statement_ns": 295081, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3758, + "serialized_bytes": 1300, + "statement_ns": 310128, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1893, + "serialized_bytes": 610, + "statement_ns": 367596, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 2335, + "serialized_bytes": 610, + "statement_ns": 282688, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3085, + "serialized_bytes": 1034, + "statement_ns": 299839, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3336, + "serialized_bytes": 1073, + "statement_ns": 310669, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3627, + "serialized_bytes": 1081, + "statement_ns": 310178, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3527, + "serialized_bytes": 1296, + "statement_ns": 318534, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2274, + "serialized_bytes": 612, + "statement_ns": 376052, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2315, + "serialized_bytes": 612, + "statement_ns": 281074, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3016, + "serialized_bytes": 1038, + "statement_ns": 320718, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3216, + "serialized_bytes": 1077, + "statement_ns": 313815, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3367, + "serialized_bytes": 1085, + "statement_ns": 289400, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3576, + "serialized_bytes": 1300, + "statement_ns": 282678, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1953, + "serialized_bytes": 612, + "statement_ns": 368438, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2284, + "serialized_bytes": 612, + "statement_ns": 325116, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2936, + "serialized_bytes": 1038, + "statement_ns": 302564, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3326, + "serialized_bytes": 1077, + "statement_ns": 325297, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3447, + "serialized_bytes": 1085, + "statement_ns": 293267, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3477, + "serialized_bytes": 1300, + "statement_ns": 326930, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1893, + "serialized_bytes": 612, + "statement_ns": 317823, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2364, + "serialized_bytes": 612, + "statement_ns": 340235, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2845, + "serialized_bytes": 1038, + "statement_ns": 298627, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3126, + "serialized_bytes": 1077, + "statement_ns": 359260, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3616, + "serialized_bytes": 1085, + "statement_ns": 294128, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3396, + "serialized_bytes": 1300, + "statement_ns": 294990, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 1934, + "serialized_bytes": 612, + "statement_ns": 326979, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2354, + "serialized_bytes": 612, + "statement_ns": 487179, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3076, + "serialized_bytes": 1038, + "statement_ns": 418951, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3416, + "serialized_bytes": 1077, + "statement_ns": 306672, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3547, + "serialized_bytes": 1085, + "statement_ns": 288067, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3526, + "serialized_bytes": 1300, + "statement_ns": 372064, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2635, + "serialized_bytes": 610, + "statement_ns": 332941, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2264, + "serialized_bytes": 610, + "statement_ns": 291554, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3196, + "serialized_bytes": 1034, + "statement_ns": 292726, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3566, + "serialized_bytes": 1073, + "statement_ns": 304217, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3466, + "serialized_bytes": 1081, + "statement_ns": 293457, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3537, + "serialized_bytes": 1296, + "statement_ns": 330516, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2054, + "serialized_bytes": 610, + "statement_ns": 341617, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 2254, + "serialized_bytes": 610, + "statement_ns": 285001, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2905, + "serialized_bytes": 1034, + "statement_ns": 297625, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3216, + "serialized_bytes": 1073, + "statement_ns": 299639, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3287, + "serialized_bytes": 1081, + "statement_ns": 286955, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3346, + "serialized_bytes": 1296, + "statement_ns": 320728, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 1924, + "serialized_bytes": 612, + "statement_ns": 336147, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2325, + "serialized_bytes": 612, + "statement_ns": 292966, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2915, + "serialized_bytes": 1038, + "statement_ns": 316972, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3446, + "serialized_bytes": 1077, + "statement_ns": 295291, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3396, + "serialized_bytes": 1085, + "statement_ns": 284661, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3657, + "serialized_bytes": 1300, + "statement_ns": 287566, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 1904, + "serialized_bytes": 612, + "statement_ns": 360943, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2315, + "serialized_bytes": 612, + "statement_ns": 276856, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2936, + "serialized_bytes": 1038, + "statement_ns": 342208, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3336, + "serialized_bytes": 1077, + "statement_ns": 402972, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3596, + "serialized_bytes": 1085, + "statement_ns": 299779, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3257, + "serialized_bytes": 1300, + "statement_ns": 338571, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2304, + "serialized_bytes": 612, + "statement_ns": 314386, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2274, + "serialized_bytes": 612, + "statement_ns": 268080, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2915, + "serialized_bytes": 1038, + "statement_ns": 358529, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3196, + "serialized_bytes": 1077, + "statement_ns": 340355, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3346, + "serialized_bytes": 1085, + "statement_ns": 283379, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3596, + "serialized_bytes": 1300, + "statement_ns": 276576, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 981300, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=1", + "COMPILER=gcc-11.4.0", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_PTHREADS", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "HTTP", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 157093754, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 125506782, + 125408379, + 125676719, + 125636114, + 125593043, + 125549692, + 125506311, + 125461929, + 125422304, + 125380977, + 125338659, + 125295588, + 125254181, + 125208756, + 125165285, + 125122345, + 125081799, + 125040052, + 124997112, + 124947239, + 124884481, + 124831273, + 124783423, + 124729352, + 124687303, + 124644944, + 124601344, + 124552091, + 124512007, + 124472694, + 153531469, + 155445399 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 36963439, + 63014234, + 191778, + 142696, + 128309, + 134782, + 130413 + ], + "failures": 0, + "in_window_samples": 5, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 36963439, + "end_ns": 47958598, + "in_window": true, + "scheduled_ns": null, + "start_ns": 10995159, + "success": true + }, + { + "elapsed_ns": 63014234, + "end_ns": 121061565, + "in_window": true, + "scheduled_ns": null, + "start_ns": 58047331, + "success": true + }, + { + "elapsed_ns": 191778, + "end_ns": 131330337, + "in_window": true, + "scheduled_ns": null, + "start_ns": 131138559, + "success": true + }, + { + "elapsed_ns": 142696, + "end_ns": 141547682, + "in_window": true, + "scheduled_ns": null, + "start_ns": 141404986, + "success": true + }, + { + "elapsed_ns": 128309, + "end_ns": 151750150, + "in_window": true, + "scheduled_ns": null, + "start_ns": 151621841, + "success": true + }, + { + "elapsed_ns": 134782, + "end_ns": 161959021, + "in_window": false, + "scheduled_ns": null, + "start_ns": 161824239, + "success": true + }, + { + "elapsed_ns": 130413, + "end_ns": 172163783, + "in_window": false, + "scheduled_ns": null, + "start_ns": 172033370, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 42429814, + 65844873, + 382275, + 611012, + 809663, + 1062024, + 173267, + 336752 + ], + "failures": 0, + "in_window_samples": 5, + "missed_periods": 10, + "samples": [ + { + "elapsed_ns": 42429814, + "end_ns": 54419204, + "in_window": true, + "scheduled_ns": 11989390, + "start_ns": 54419204, + "success": true + }, + { + "elapsed_ns": 65844873, + "end_ns": 127834263, + "in_window": true, + "scheduled_ns": 61989390, + "start_ns": 127834263, + "success": true + }, + { + "elapsed_ns": 382275, + "end_ns": 132371665, + "in_window": true, + "scheduled_ns": 131989390, + "start_ns": 132371665, + "success": true + }, + { + "elapsed_ns": 611012, + "end_ns": 142600402, + "in_window": true, + "scheduled_ns": 141989390, + "start_ns": 142600402, + "success": true + }, + { + "elapsed_ns": 809663, + "end_ns": 152799053, + "in_window": true, + "scheduled_ns": 151989390, + "start_ns": 152799053, + "success": true + }, + { + "elapsed_ns": 1062024, + "end_ns": 163051414, + "in_window": false, + "scheduled_ns": 161989390, + "start_ns": 163051414, + "success": true + }, + { + "elapsed_ns": 173267, + "end_ns": 172162657, + "in_window": false, + "scheduled_ns": 171989390, + "start_ns": 172162657, + "success": true + }, + { + "elapsed_ns": 336752, + "end_ns": 182326142, + "in_window": false, + "scheduled_ns": 181989390, + "start_ns": 182326142, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 159087602, + "window_start_ns": 1993848 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 0, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 120, + "serialization_ns": 3978, + "serialized_bytes": 613, + "statement_ns": 591944, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3547, + "serialized_bytes": 613, + "statement_ns": 329985, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3867, + "serialized_bytes": 1040, + "statement_ns": 286554, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3817, + "serialized_bytes": 1079, + "statement_ns": 327962, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4147, + "serialized_bytes": 1087, + "statement_ns": 306822, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3667, + "serialized_bytes": 1302, + "statement_ns": 292405, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2355, + "serialized_bytes": 611, + "statement_ns": 382693, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2515, + "serialized_bytes": 611, + "statement_ns": 286594, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3757, + "serialized_bytes": 1036, + "statement_ns": 318885, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3696, + "serialized_bytes": 1075, + "statement_ns": 332950, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3647, + "serialized_bytes": 1083, + "statement_ns": 288789, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4538, + "serialized_bytes": 1298, + "statement_ns": 286575, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2254, + "serialized_bytes": 613, + "statement_ns": 379147, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2384, + "serialized_bytes": 613, + "statement_ns": 280663, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3226, + "serialized_bytes": 1040, + "statement_ns": 306452, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3487, + "serialized_bytes": 1079, + "statement_ns": 444589, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3637, + "serialized_bytes": 1087, + "statement_ns": 314747, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 4017, + "serialized_bytes": 1302, + "statement_ns": 334844, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 1943, + "serialized_bytes": 613, + "statement_ns": 309327, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2325, + "serialized_bytes": 613, + "statement_ns": 266447, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3026, + "serialized_bytes": 1040, + "statement_ns": 300430, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3427, + "serialized_bytes": 1079, + "statement_ns": 298377, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3637, + "serialized_bytes": 1087, + "statement_ns": 287626, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3987, + "serialized_bytes": 1302, + "statement_ns": 319646, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2054, + "serialized_bytes": 613, + "statement_ns": 358449, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 2424, + "serialized_bytes": 613, + "statement_ns": 292585, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3086, + "serialized_bytes": 1040, + "statement_ns": 305099, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3367, + "serialized_bytes": 1079, + "statement_ns": 290311, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3486, + "serialized_bytes": 1087, + "statement_ns": 277147, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3908, + "serialized_bytes": 1302, + "statement_ns": 315379, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 1994, + "serialized_bytes": 613, + "statement_ns": 471440, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2335, + "serialized_bytes": 613, + "statement_ns": 340234, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2956, + "serialized_bytes": 1040, + "statement_ns": 344833, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3236, + "serialized_bytes": 1079, + "statement_ns": 337530, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3867, + "serialized_bytes": 1087, + "statement_ns": 292455, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3878, + "serialized_bytes": 1302, + "statement_ns": 302805, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2164, + "serialized_bytes": 611, + "statement_ns": 369730, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2284, + "serialized_bytes": 611, + "statement_ns": 280984, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3035, + "serialized_bytes": 1036, + "statement_ns": 304208, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3596, + "serialized_bytes": 1075, + "statement_ns": 290943, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3646, + "serialized_bytes": 1083, + "statement_ns": 295040, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3677, + "serialized_bytes": 1298, + "statement_ns": 341076, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 1893, + "serialized_bytes": 613, + "statement_ns": 315699, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2274, + "serialized_bytes": 613, + "statement_ns": 286464, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2905, + "serialized_bytes": 1040, + "statement_ns": 321750, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3215, + "serialized_bytes": 1079, + "statement_ns": 290983, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3587, + "serialized_bytes": 1087, + "statement_ns": 340044, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3547, + "serialized_bytes": 1302, + "statement_ns": 348690, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 1904, + "serialized_bytes": 613, + "statement_ns": 312302, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2304, + "serialized_bytes": 613, + "statement_ns": 298203, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4298, + "serialized_bytes": 1040, + "statement_ns": 389116, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3747, + "serialized_bytes": 1079, + "statement_ns": 325768, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3777, + "serialized_bytes": 1087, + "statement_ns": 301613, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 4328, + "serialized_bytes": 1302, + "statement_ns": 389347, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2154, + "serialized_bytes": 613, + "statement_ns": 331378, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2484, + "serialized_bytes": 613, + "statement_ns": 356295, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3356, + "serialized_bytes": 1040, + "statement_ns": 315298, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3567, + "serialized_bytes": 1079, + "statement_ns": 291524, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3657, + "serialized_bytes": 1087, + "statement_ns": 304357, + "success": true + }, + { + "mutex_wait_ns": 60, + "serialization_ns": 3997, + "serialized_bytes": 1302, + "statement_ns": 325628, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2174, + "serialized_bytes": 613, + "statement_ns": 329434, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2595, + "serialized_bytes": 613, + "statement_ns": 366794, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3406, + "serialized_bytes": 1040, + "statement_ns": 358158, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3567, + "serialized_bytes": 1079, + "statement_ns": 299559, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3507, + "serialized_bytes": 1087, + "statement_ns": 330466, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 3697, + "serialized_bytes": 1302, + "statement_ns": 330827, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2094, + "serialized_bytes": 613, + "statement_ns": 320929, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2415, + "serialized_bytes": 613, + "statement_ns": 326529, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3106, + "serialized_bytes": 1040, + "statement_ns": 316780, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3296, + "serialized_bytes": 1079, + "statement_ns": 282667, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3537, + "serialized_bytes": 1087, + "statement_ns": 317121, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3457, + "serialized_bytes": 1302, + "statement_ns": 284640, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 1943, + "serialized_bytes": 611, + "statement_ns": 310549, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2385, + "serialized_bytes": 611, + "statement_ns": 321209, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3076, + "serialized_bytes": 1036, + "statement_ns": 309266, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3317, + "serialized_bytes": 1075, + "statement_ns": 2683555, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3727, + "serialized_bytes": 1083, + "statement_ns": 599337, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3867, + "serialized_bytes": 1298, + "statement_ns": 429000, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2084, + "serialized_bytes": 613, + "statement_ns": 393905, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2414, + "serialized_bytes": 613, + "statement_ns": 315749, + "success": true + }, + { + "mutex_wait_ns": 51, + "serialization_ns": 20919, + "serialized_bytes": 1040, + "statement_ns": 368026, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3426, + "serialized_bytes": 1079, + "statement_ns": 316110, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3496, + "serialized_bytes": 1087, + "statement_ns": 335887, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3787, + "serialized_bytes": 1302, + "statement_ns": 335005, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1903, + "serialized_bytes": 613, + "statement_ns": 326509, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2445, + "serialized_bytes": 613, + "statement_ns": 292606, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3086, + "serialized_bytes": 1040, + "statement_ns": 318574, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3246, + "serialized_bytes": 1079, + "statement_ns": 306551, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3467, + "serialized_bytes": 1087, + "statement_ns": 371022, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4007, + "serialized_bytes": 1302, + "statement_ns": 379548, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2064, + "serialized_bytes": 613, + "statement_ns": 361775, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2594, + "serialized_bytes": 613, + "statement_ns": 364200, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3296, + "serialized_bytes": 1040, + "statement_ns": 305049, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3286, + "serialized_bytes": 1079, + "statement_ns": 306952, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3537, + "serialized_bytes": 1087, + "statement_ns": 338180, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3677, + "serialized_bytes": 1302, + "statement_ns": 302805, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1934, + "serialized_bytes": 613, + "statement_ns": 355453, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2585, + "serialized_bytes": 613, + "statement_ns": 288869, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3016, + "serialized_bytes": 1040, + "statement_ns": 310058, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3215, + "serialized_bytes": 1079, + "statement_ns": 296432, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3306, + "serialized_bytes": 1087, + "statement_ns": 343231, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3767, + "serialized_bytes": 1302, + "statement_ns": 335355, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2014, + "serialized_bytes": 613, + "statement_ns": 352879, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2545, + "serialized_bytes": 613, + "statement_ns": 292064, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3116, + "serialized_bytes": 1040, + "statement_ns": 293267, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3287, + "serialized_bytes": 1079, + "statement_ns": 292635, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3377, + "serialized_bytes": 1087, + "statement_ns": 327160, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3597, + "serialized_bytes": 1302, + "statement_ns": 287516, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2074, + "serialized_bytes": 611, + "statement_ns": 370070, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2445, + "serialized_bytes": 611, + "statement_ns": 283589, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3206, + "serialized_bytes": 1036, + "statement_ns": 291935, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3316, + "serialized_bytes": 1075, + "statement_ns": 281445, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3747, + "serialized_bytes": 1083, + "statement_ns": 349883, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3777, + "serialized_bytes": 1298, + "statement_ns": 428499, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2195, + "serialized_bytes": 611, + "statement_ns": 369399, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2926, + "serialized_bytes": 611, + "statement_ns": 292285, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3176, + "serialized_bytes": 1036, + "statement_ns": 319416, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3186, + "serialized_bytes": 1075, + "statement_ns": 342770, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3436, + "serialized_bytes": 1083, + "statement_ns": 335847, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3647, + "serialized_bytes": 1298, + "statement_ns": 306692, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1913, + "serialized_bytes": 613, + "statement_ns": 342018, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2585, + "serialized_bytes": 613, + "statement_ns": 347638, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3146, + "serialized_bytes": 1040, + "statement_ns": 316982, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3096, + "serialized_bytes": 1079, + "statement_ns": 317462, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3466, + "serialized_bytes": 1087, + "statement_ns": 299609, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3747, + "serialized_bytes": 1302, + "statement_ns": 321640, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2175, + "serialized_bytes": 613, + "statement_ns": 387192, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2765, + "serialized_bytes": 613, + "statement_ns": 285102, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3316, + "serialized_bytes": 1040, + "statement_ns": 324445, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3296, + "serialized_bytes": 1079, + "statement_ns": 444028, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3747, + "serialized_bytes": 1087, + "statement_ns": 344883, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3557, + "serialized_bytes": 1302, + "statement_ns": 306131, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1884, + "serialized_bytes": 611, + "statement_ns": 325026, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2444, + "serialized_bytes": 611, + "statement_ns": 275354, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2936, + "serialized_bytes": 1036, + "statement_ns": 295330, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3206, + "serialized_bytes": 1075, + "statement_ns": 312563, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3356, + "serialized_bytes": 1083, + "statement_ns": 288118, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3667, + "serialized_bytes": 1298, + "statement_ns": 386251, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 1994, + "serialized_bytes": 611, + "statement_ns": 377284, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2645, + "serialized_bytes": 611, + "statement_ns": 320408, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3025, + "serialized_bytes": 1036, + "statement_ns": 310219, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3367, + "serialized_bytes": 1075, + "statement_ns": 298757, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3456, + "serialized_bytes": 1083, + "statement_ns": 291935, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3547, + "serialized_bytes": 1298, + "statement_ns": 324365, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 1893, + "serialized_bytes": 611, + "statement_ns": 327080, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2535, + "serialized_bytes": 611, + "statement_ns": 286555, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2925, + "serialized_bytes": 1036, + "statement_ns": 335125, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3156, + "serialized_bytes": 1075, + "statement_ns": 310569, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3497, + "serialized_bytes": 1083, + "statement_ns": 303005, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3276, + "serialized_bytes": 1298, + "statement_ns": 360612, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 1924, + "serialized_bytes": 613, + "statement_ns": 329705, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2504, + "serialized_bytes": 613, + "statement_ns": 290282, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2905, + "serialized_bytes": 1040, + "statement_ns": 349182, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3286, + "serialized_bytes": 1079, + "statement_ns": 294168, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3446, + "serialized_bytes": 1087, + "statement_ns": 284180, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3797, + "serialized_bytes": 1302, + "statement_ns": 300430, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2043, + "serialized_bytes": 613, + "statement_ns": 323444, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2515, + "serialized_bytes": 613, + "statement_ns": 278078, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3146, + "serialized_bytes": 1040, + "statement_ns": 326018, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3457, + "serialized_bytes": 1079, + "statement_ns": 589890, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3617, + "serialized_bytes": 1087, + "statement_ns": 420584, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3537, + "serialized_bytes": 1302, + "statement_ns": 390739, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1914, + "serialized_bytes": 613, + "statement_ns": 386781, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2825, + "serialized_bytes": 613, + "statement_ns": 288699, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2835, + "serialized_bytes": 1040, + "statement_ns": 285633, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3156, + "serialized_bytes": 1079, + "statement_ns": 341046, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3396, + "serialized_bytes": 1087, + "statement_ns": 304899, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3306, + "serialized_bytes": 1302, + "statement_ns": 315820, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2505, + "serialized_bytes": 613, + "statement_ns": 386831, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2455, + "serialized_bytes": 613, + "statement_ns": 334834, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2916, + "serialized_bytes": 1040, + "statement_ns": 308005, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3116, + "serialized_bytes": 1079, + "statement_ns": 333723, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3416, + "serialized_bytes": 1087, + "statement_ns": 356104, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3777, + "serialized_bytes": 1302, + "statement_ns": 375270, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2184, + "serialized_bytes": 611, + "statement_ns": 391430, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2404, + "serialized_bytes": 611, + "statement_ns": 294540, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2915, + "serialized_bytes": 1036, + "statement_ns": 323323, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3197, + "serialized_bytes": 1075, + "statement_ns": 333101, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3486, + "serialized_bytes": 1083, + "statement_ns": 341658, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3637, + "serialized_bytes": 1298, + "statement_ns": 400828, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1984, + "serialized_bytes": 611, + "statement_ns": 367274, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2224, + "serialized_bytes": 611, + "statement_ns": 333873, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3957, + "serialized_bytes": 1036, + "statement_ns": 345675, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3396, + "serialized_bytes": 1075, + "statement_ns": 316901, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3316, + "serialized_bytes": 1083, + "statement_ns": 318204, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 4438, + "serialized_bytes": 1298, + "statement_ns": 373387, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 2003, + "serialized_bytes": 613, + "statement_ns": 336598, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2244, + "serialized_bytes": 613, + "statement_ns": 312543, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3146, + "serialized_bytes": 1040, + "statement_ns": 326790, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3366, + "serialized_bytes": 1079, + "statement_ns": 294610, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3657, + "serialized_bytes": 1087, + "statement_ns": 293708, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3918, + "serialized_bytes": 1302, + "statement_ns": 350163, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 538785, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=1", + "COMPILER=gcc-11.4.0", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_PTHREADS", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "TLS", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 131552609, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 101829463, + 101788025, + 101745637, + 101703188, + 101660068, + 101618620, + 101576080, + 101508846, + 101465043, + 101421062, + 101380335, + 101338166, + 101295818, + 102048101, + 101258949, + 101968563, + 101223994, + 101182035, + 101139446, + 101097308, + 101054538, + 101012680, + 100962937, + 100921089, + 100878920, + 100829619, + 100779745, + 100749779, + 100708142, + 100614166, + 127930162, + 129860182 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 6841890, + 76538187, + 159638, + 121887, + 141814, + 154689 + ], + "failures": 0, + "in_window_samples": 4, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 6841890, + "end_ns": 18012465, + "in_window": true, + "scheduled_ns": null, + "start_ns": 11170575, + "success": true + }, + { + "elapsed_ns": 76538187, + "end_ns": 104621956, + "in_window": true, + "scheduled_ns": null, + "start_ns": 28083769, + "success": true + }, + { + "elapsed_ns": 159638, + "end_ns": 114857025, + "in_window": true, + "scheduled_ns": null, + "start_ns": 114697387, + "success": true + }, + { + "elapsed_ns": 121887, + "end_ns": 125048762, + "in_window": true, + "scheduled_ns": null, + "start_ns": 124926875, + "success": true + }, + { + "elapsed_ns": 141814, + "end_ns": 135264405, + "in_window": false, + "scheduled_ns": null, + "start_ns": 135122591, + "success": true + }, + { + "elapsed_ns": 154689, + "end_ns": 145493864, + "in_window": false, + "scheduled_ns": null, + "start_ns": 145339175, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 12287838, + 71974384, + 1264540, + 1047386, + 1538833, + 1389625, + 1634021 + ], + "failures": 0, + "in_window_samples": 5, + "missed_periods": 8, + "samples": [ + { + "elapsed_ns": 12287838, + "end_ns": 25218213, + "in_window": true, + "scheduled_ns": 12930375, + "start_ns": 25218213, + "success": true + }, + { + "elapsed_ns": 71974384, + "end_ns": 104904759, + "in_window": true, + "scheduled_ns": 32930375, + "start_ns": 104904759, + "success": true + }, + { + "elapsed_ns": 1264540, + "end_ns": 114194915, + "in_window": true, + "scheduled_ns": 112930375, + "start_ns": 114194915, + "success": true + }, + { + "elapsed_ns": 1047386, + "end_ns": 123977761, + "in_window": true, + "scheduled_ns": 122930375, + "start_ns": 123977761, + "success": true + }, + { + "elapsed_ns": 1538833, + "end_ns": 134469208, + "in_window": true, + "scheduled_ns": 132930375, + "start_ns": 134469208, + "success": true + }, + { + "elapsed_ns": 1389625, + "end_ns": 144320000, + "in_window": false, + "scheduled_ns": 142930375, + "start_ns": 144320000, + "success": true + }, + { + "elapsed_ns": 1634021, + "end_ns": 154564396, + "in_window": false, + "scheduled_ns": 152930375, + "start_ns": 154564396, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 134486901, + "window_start_ns": 2934292 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 1, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 40, + "serialization_ns": 3126, + "serialized_bytes": 613, + "statement_ns": 610809, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2705, + "serialized_bytes": 613, + "statement_ns": 421607, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4078, + "serialized_bytes": 1040, + "statement_ns": 460439, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4028, + "serialized_bytes": 1079, + "statement_ns": 438518, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4037, + "serialized_bytes": 1087, + "statement_ns": 445170, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3807, + "serialized_bytes": 1302, + "statement_ns": 379718, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2023, + "serialized_bytes": 611, + "statement_ns": 366564, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2405, + "serialized_bytes": 611, + "statement_ns": 429371, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3397, + "serialized_bytes": 1036, + "statement_ns": 451733, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3627, + "serialized_bytes": 1075, + "statement_ns": 432827, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3877, + "serialized_bytes": 1083, + "statement_ns": 372335, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3647, + "serialized_bytes": 1298, + "statement_ns": 319536, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2053, + "serialized_bytes": 613, + "statement_ns": 556058, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2204, + "serialized_bytes": 613, + "statement_ns": 430013, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3296, + "serialized_bytes": 1040, + "statement_ns": 416547, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3727, + "serialized_bytes": 1079, + "statement_ns": 390936, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4369, + "serialized_bytes": 1087, + "statement_ns": 518086, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 4017, + "serialized_bytes": 1302, + "statement_ns": 404123, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 1884, + "serialized_bytes": 613, + "statement_ns": 481247, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2454, + "serialized_bytes": 613, + "statement_ns": 425403, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3186, + "serialized_bytes": 1040, + "statement_ns": 472842, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3787, + "serialized_bytes": 1079, + "statement_ns": 351676, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3887, + "serialized_bytes": 1087, + "statement_ns": 449859, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3947, + "serialized_bytes": 1302, + "statement_ns": 384357, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2114, + "serialized_bytes": 613, + "statement_ns": 377755, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2475, + "serialized_bytes": 613, + "statement_ns": 371453, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3176, + "serialized_bytes": 1040, + "statement_ns": 350414, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3517, + "serialized_bytes": 1079, + "statement_ns": 364600, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3606, + "serialized_bytes": 1087, + "statement_ns": 406588, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3807, + "serialized_bytes": 1302, + "statement_ns": 440792, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2093, + "serialized_bytes": 613, + "statement_ns": 424933, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2334, + "serialized_bytes": 613, + "statement_ns": 365331, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3096, + "serialized_bytes": 1040, + "statement_ns": 368387, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3195, + "serialized_bytes": 1079, + "statement_ns": 407941, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3617, + "serialized_bytes": 1087, + "statement_ns": 434751, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3958, + "serialized_bytes": 1302, + "statement_ns": 474435, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2114, + "serialized_bytes": 613, + "statement_ns": 420995, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2615, + "serialized_bytes": 613, + "statement_ns": 392182, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3176, + "serialized_bytes": 1040, + "statement_ns": 367776, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3406, + "serialized_bytes": 1079, + "statement_ns": 375110, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3637, + "serialized_bytes": 1087, + "statement_ns": 448055, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3807, + "serialized_bytes": 1302, + "statement_ns": 558411, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 1783, + "serialized_bytes": 613, + "statement_ns": 489984, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2334, + "serialized_bytes": 613, + "statement_ns": 361634, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3056, + "serialized_bytes": 1040, + "statement_ns": 354060, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3507, + "serialized_bytes": 1079, + "statement_ns": 353830, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3797, + "serialized_bytes": 1087, + "statement_ns": 346697, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3938, + "serialized_bytes": 1302, + "statement_ns": 382614, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 2335, + "serialized_bytes": 611, + "statement_ns": 543994, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2444, + "serialized_bytes": 611, + "statement_ns": 430674, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3336, + "serialized_bytes": 1036, + "statement_ns": 398734, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3507, + "serialized_bytes": 1075, + "statement_ns": 404013, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3706, + "serialized_bytes": 1083, + "statement_ns": 363247, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3887, + "serialized_bytes": 1298, + "statement_ns": 394065, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1874, + "serialized_bytes": 613, + "statement_ns": 491156, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2445, + "serialized_bytes": 613, + "statement_ns": 356064, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4468, + "serialized_bytes": 1040, + "statement_ns": 405196, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3527, + "serialized_bytes": 1079, + "statement_ns": 389025, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3657, + "serialized_bytes": 1087, + "statement_ns": 374438, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5581, + "serialized_bytes": 1302, + "statement_ns": 353780, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 1854, + "serialized_bytes": 611, + "statement_ns": 364931, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 2164, + "serialized_bytes": 611, + "statement_ns": 443638, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3236, + "serialized_bytes": 1036, + "statement_ns": 379568, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3396, + "serialized_bytes": 1075, + "statement_ns": 422137, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3597, + "serialized_bytes": 1083, + "statement_ns": 356395, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3657, + "serialized_bytes": 1298, + "statement_ns": 441744, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2194, + "serialized_bytes": 613, + "statement_ns": 431966, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2615, + "serialized_bytes": 613, + "statement_ns": 421426, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3246, + "serialized_bytes": 1040, + "statement_ns": 387412, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3666, + "serialized_bytes": 1079, + "statement_ns": 342398, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3787, + "serialized_bytes": 1087, + "statement_ns": 368467, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3837, + "serialized_bytes": 1302, + "statement_ns": 373947, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2074, + "serialized_bytes": 613, + "statement_ns": 359340, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2534, + "serialized_bytes": 613, + "statement_ns": 348129, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3466, + "serialized_bytes": 1040, + "statement_ns": 347719, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3487, + "serialized_bytes": 1079, + "statement_ns": 420765, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3416, + "serialized_bytes": 1087, + "statement_ns": 385359, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3747, + "serialized_bytes": 1302, + "statement_ns": 453396, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2164, + "serialized_bytes": 613, + "statement_ns": 431605, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2625, + "serialized_bytes": 613, + "statement_ns": 372023, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3196, + "serialized_bytes": 1040, + "statement_ns": 343020, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3367, + "serialized_bytes": 1079, + "statement_ns": 470838, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3817, + "serialized_bytes": 1087, + "statement_ns": 367064, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3757, + "serialized_bytes": 1302, + "statement_ns": 377965, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 1864, + "serialized_bytes": 611, + "statement_ns": 370791, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2374, + "serialized_bytes": 611, + "statement_ns": 327772, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3135, + "serialized_bytes": 1036, + "statement_ns": 471158, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3396, + "serialized_bytes": 1075, + "statement_ns": 455369, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3607, + "serialized_bytes": 1083, + "statement_ns": 532022, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3948, + "serialized_bytes": 1298, + "statement_ns": 421466, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2024, + "serialized_bytes": 611, + "statement_ns": 465518, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2645, + "serialized_bytes": 611, + "statement_ns": 421697, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3116, + "serialized_bytes": 1036, + "statement_ns": 380499, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3497, + "serialized_bytes": 1075, + "statement_ns": 393284, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3516, + "serialized_bytes": 1083, + "statement_ns": 491237, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3938, + "serialized_bytes": 1298, + "statement_ns": 379708, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1853, + "serialized_bytes": 611, + "statement_ns": 411167, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2414, + "serialized_bytes": 611, + "statement_ns": 412610, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3346, + "serialized_bytes": 1036, + "statement_ns": 428249, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3346, + "serialized_bytes": 1075, + "statement_ns": 373376, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3717, + "serialized_bytes": 1083, + "statement_ns": 445712, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3867, + "serialized_bytes": 1298, + "statement_ns": 478643, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1914, + "serialized_bytes": 613, + "statement_ns": 421285, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2895, + "serialized_bytes": 613, + "statement_ns": 449038, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3216, + "serialized_bytes": 1040, + "statement_ns": 381872, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3397, + "serialized_bytes": 1079, + "statement_ns": 388083, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3527, + "serialized_bytes": 1087, + "statement_ns": 398754, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3997, + "serialized_bytes": 1302, + "statement_ns": 408532, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2194, + "serialized_bytes": 613, + "statement_ns": 535278, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3036, + "serialized_bytes": 613, + "statement_ns": 383806, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3025, + "serialized_bytes": 1040, + "statement_ns": 370440, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3446, + "serialized_bytes": 1079, + "statement_ns": 387764, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3837, + "serialized_bytes": 1087, + "statement_ns": 361474, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3967, + "serialized_bytes": 1302, + "statement_ns": 411929, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 1874, + "serialized_bytes": 613, + "statement_ns": 478482, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2504, + "serialized_bytes": 613, + "statement_ns": 349432, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 8706, + "serialized_bytes": 1040, + "statement_ns": 391180, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3477, + "serialized_bytes": 1079, + "statement_ns": 434210, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3596, + "serialized_bytes": 1087, + "statement_ns": 460378, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3958, + "serialized_bytes": 1302, + "statement_ns": 354932, + "success": true + }, + { + "mutex_wait_ns": 60, + "serialization_ns": 2004, + "serialized_bytes": 613, + "statement_ns": 742294, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2514, + "serialized_bytes": 613, + "statement_ns": 338402, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3146, + "serialized_bytes": 1040, + "statement_ns": 588898, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3357, + "serialized_bytes": 1079, + "statement_ns": 412629, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3697, + "serialized_bytes": 1087, + "statement_ns": 496433, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4699, + "serialized_bytes": 1302, + "statement_ns": 471409, + "success": true + }, + { + "mutex_wait_ns": 51, + "serialization_ns": 3376, + "serialized_bytes": 611, + "statement_ns": 503188, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2685, + "serialized_bytes": 611, + "statement_ns": 493601, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5100, + "serialized_bytes": 1036, + "statement_ns": 463635, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3287, + "serialized_bytes": 1075, + "statement_ns": 409353, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3536, + "serialized_bytes": 1083, + "statement_ns": 396389, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 4107, + "serialized_bytes": 1298, + "statement_ns": 413010, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2144, + "serialized_bytes": 611, + "statement_ns": 511484, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2735, + "serialized_bytes": 611, + "statement_ns": 340245, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3416, + "serialized_bytes": 1036, + "statement_ns": 396380, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3427, + "serialized_bytes": 1075, + "statement_ns": 345865, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3527, + "serialized_bytes": 1083, + "statement_ns": 339824, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3627, + "serialized_bytes": 1298, + "statement_ns": 465698, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2064, + "serialized_bytes": 611, + "statement_ns": 463335, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2805, + "serialized_bytes": 611, + "statement_ns": 444459, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3186, + "serialized_bytes": 1036, + "statement_ns": 358178, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3406, + "serialized_bytes": 1075, + "statement_ns": 424943, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3557, + "serialized_bytes": 1083, + "statement_ns": 388324, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3677, + "serialized_bytes": 1298, + "statement_ns": 403834, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2144, + "serialized_bytes": 611, + "statement_ns": 510312, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 2726, + "serialized_bytes": 611, + "statement_ns": 369089, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3326, + "serialized_bytes": 1036, + "statement_ns": 406408, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3476, + "serialized_bytes": 1075, + "statement_ns": 361915, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3477, + "serialized_bytes": 1083, + "statement_ns": 439750, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3947, + "serialized_bytes": 1298, + "statement_ns": 437746, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 2174, + "serialized_bytes": 613, + "statement_ns": 536036, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4038, + "serialized_bytes": 613, + "statement_ns": 439560, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3346, + "serialized_bytes": 1040, + "statement_ns": 448262, + "success": true + }, + { + "mutex_wait_ns": 60, + "serialization_ns": 4799, + "serialized_bytes": 1079, + "statement_ns": 406628, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3977, + "serialized_bytes": 1087, + "statement_ns": 356125, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3987, + "serialized_bytes": 1302, + "statement_ns": 345264, + "success": true + }, + { + "mutex_wait_ns": 60, + "serialization_ns": 1914, + "serialized_bytes": 613, + "statement_ns": 369519, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2575, + "serialized_bytes": 613, + "statement_ns": 534577, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3317, + "serialized_bytes": 1040, + "statement_ns": 653399, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3416, + "serialized_bytes": 1079, + "statement_ns": 497858, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3687, + "serialized_bytes": 1087, + "statement_ns": 411527, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3727, + "serialized_bytes": 1302, + "statement_ns": 490325, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2184, + "serialized_bytes": 613, + "statement_ns": 454017, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2335, + "serialized_bytes": 613, + "statement_ns": 447004, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3096, + "serialized_bytes": 1040, + "statement_ns": 474195, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3156, + "serialized_bytes": 1079, + "statement_ns": 393945, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3446, + "serialized_bytes": 1087, + "statement_ns": 363748, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3847, + "serialized_bytes": 1302, + "statement_ns": 434321, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2044, + "serialized_bytes": 613, + "statement_ns": 392792, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2224, + "serialized_bytes": 613, + "statement_ns": 372876, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3276, + "serialized_bytes": 1040, + "statement_ns": 386982, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3366, + "serialized_bytes": 1079, + "statement_ns": 370822, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3527, + "serialized_bytes": 1087, + "statement_ns": 429772, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3566, + "serialized_bytes": 1302, + "statement_ns": 370431, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1974, + "serialized_bytes": 613, + "statement_ns": 447955, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2264, + "serialized_bytes": 613, + "statement_ns": 396349, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2995, + "serialized_bytes": 1040, + "statement_ns": 379718, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3076, + "serialized_bytes": 1079, + "statement_ns": 408903, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3506, + "serialized_bytes": 1087, + "statement_ns": 438157, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3697, + "serialized_bytes": 1302, + "statement_ns": 438448, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1863, + "serialized_bytes": 613, + "statement_ns": 429401, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 2194, + "serialized_bytes": 613, + "statement_ns": 453666, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3186, + "serialized_bytes": 1040, + "statement_ns": 417499, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3467, + "serialized_bytes": 1079, + "statement_ns": 388364, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3457, + "serialized_bytes": 1087, + "statement_ns": 377524, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3547, + "serialized_bytes": 1302, + "statement_ns": 451202, + "success": true + }, + { + "mutex_wait_ns": 60, + "serialization_ns": 1883, + "serialized_bytes": 613, + "statement_ns": 449479, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2495, + "serialized_bytes": 613, + "statement_ns": 356765, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2955, + "serialized_bytes": 1040, + "statement_ns": 323443, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3055, + "serialized_bytes": 1079, + "statement_ns": 383836, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3677, + "serialized_bytes": 1087, + "statement_ns": 361555, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3778, + "serialized_bytes": 1302, + "statement_ns": 458155, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 482820, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=1", + "COMPILER=gcc-11.4.0", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_PTHREADS", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "TLS", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 121759167, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 89977183, + 89935725, + 89892364, + 89850036, + 89807085, + 89764295, + 89720184, + 89680831, + 89640485, + 89599639, + 89556128, + 89479775, + 89430102, + 89384136, + 89340645, + 90193326, + 89305741, + 90118776, + 89266688, + 89222725, + 89179073, + 89136866, + 89094386, + 89051877, + 89009517, + 88968000, + 88924729, + 88894524, + 88852776, + 88809505, + 117222917, + 120160286 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 6997039, + 64397173, + 143658, + 162944, + 116938, + 140151, + 128981 + ], + "failures": 0, + "in_window_samples": 5, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 6997039, + "end_ns": 18096394, + "in_window": true, + "scheduled_ns": null, + "start_ns": 11099355, + "success": true + }, + { + "elapsed_ns": 64397173, + "end_ns": 92564360, + "in_window": true, + "scheduled_ns": null, + "start_ns": 28167187, + "success": true + }, + { + "elapsed_ns": 143658, + "end_ns": 102776817, + "in_window": true, + "scheduled_ns": null, + "start_ns": 102633159, + "success": true + }, + { + "elapsed_ns": 162944, + "end_ns": 113014280, + "in_window": true, + "scheduled_ns": null, + "start_ns": 112851336, + "success": true + }, + { + "elapsed_ns": 116938, + "end_ns": 123203634, + "in_window": true, + "scheduled_ns": null, + "start_ns": 123086696, + "success": true + }, + { + "elapsed_ns": 140151, + "end_ns": 133438452, + "in_window": false, + "scheduled_ns": null, + "start_ns": 133298301, + "success": true + }, + { + "elapsed_ns": 128981, + "end_ns": 143639257, + "in_window": false, + "scheduled_ns": null, + "start_ns": 143510276, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 10876626, + 60119138, + 1100749, + 1321090, + 1525392, + 1817116, + 873156, + 1035409 + ], + "failures": 0, + "in_window_samples": 5, + "missed_periods": 7, + "samples": [ + { + "elapsed_ns": 10876626, + "end_ns": 23651391, + "in_window": true, + "scheduled_ns": 12774765, + "start_ns": 23651391, + "success": true + }, + { + "elapsed_ns": 60119138, + "end_ns": 92893903, + "in_window": true, + "scheduled_ns": 32774765, + "start_ns": 92893903, + "success": true + }, + { + "elapsed_ns": 1100749, + "end_ns": 103875514, + "in_window": true, + "scheduled_ns": 102774765, + "start_ns": 103875514, + "success": true + }, + { + "elapsed_ns": 1321090, + "end_ns": 114095855, + "in_window": true, + "scheduled_ns": 112774765, + "start_ns": 114095855, + "success": true + }, + { + "elapsed_ns": 1525392, + "end_ns": 124300157, + "in_window": true, + "scheduled_ns": 122774765, + "start_ns": 124300157, + "success": true + }, + { + "elapsed_ns": 1817116, + "end_ns": 134591881, + "in_window": false, + "scheduled_ns": 132774765, + "start_ns": 134591881, + "success": true + }, + { + "elapsed_ns": 873156, + "end_ns": 143647921, + "in_window": false, + "scheduled_ns": 142774765, + "start_ns": 143647921, + "success": true + }, + { + "elapsed_ns": 1035409, + "end_ns": 153810174, + "in_window": false, + "scheduled_ns": 152774765, + "start_ns": 153810174, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 124537950, + "window_start_ns": 2778783 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 2, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 40, + "serialization_ns": 2966, + "serialized_bytes": 613, + "statement_ns": 460890, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2394, + "serialized_bytes": 613, + "statement_ns": 363889, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3467, + "serialized_bytes": 1040, + "statement_ns": 310488, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4138, + "serialized_bytes": 1079, + "statement_ns": 299017, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 4087, + "serialized_bytes": 1087, + "statement_ns": 361604, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3727, + "serialized_bytes": 1302, + "statement_ns": 316480, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2044, + "serialized_bytes": 611, + "statement_ns": 327941, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2394, + "serialized_bytes": 611, + "statement_ns": 294970, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3247, + "serialized_bytes": 1036, + "statement_ns": 309106, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3487, + "serialized_bytes": 1075, + "statement_ns": 326058, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3556, + "serialized_bytes": 1083, + "statement_ns": 325327, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3666, + "serialized_bytes": 1298, + "statement_ns": 293828, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 2334, + "serialized_bytes": 613, + "statement_ns": 352708, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2615, + "serialized_bytes": 613, + "statement_ns": 296663, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3416, + "serialized_bytes": 1040, + "statement_ns": 332580, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3777, + "serialized_bytes": 1079, + "statement_ns": 289250, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3727, + "serialized_bytes": 1087, + "statement_ns": 289870, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3907, + "serialized_bytes": 1302, + "statement_ns": 337859, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 2124, + "serialized_bytes": 613, + "statement_ns": 315208, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2524, + "serialized_bytes": 613, + "statement_ns": 282097, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3256, + "serialized_bytes": 1040, + "statement_ns": 344613, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3627, + "serialized_bytes": 1079, + "statement_ns": 301813, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3456, + "serialized_bytes": 1087, + "statement_ns": 335136, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3717, + "serialized_bytes": 1302, + "statement_ns": 374097, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 2004, + "serialized_bytes": 613, + "statement_ns": 312903, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2415, + "serialized_bytes": 613, + "statement_ns": 276064, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3246, + "serialized_bytes": 1040, + "statement_ns": 377304, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3657, + "serialized_bytes": 1079, + "statement_ns": 289600, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3937, + "serialized_bytes": 1087, + "statement_ns": 285393, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4007, + "serialized_bytes": 1302, + "statement_ns": 340445, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1964, + "serialized_bytes": 613, + "statement_ns": 428810, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2435, + "serialized_bytes": 613, + "statement_ns": 393363, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3246, + "serialized_bytes": 1040, + "statement_ns": 338792, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3436, + "serialized_bytes": 1079, + "statement_ns": 353730, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3547, + "serialized_bytes": 1087, + "statement_ns": 350072, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3717, + "serialized_bytes": 1302, + "statement_ns": 318194, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2204, + "serialized_bytes": 611, + "statement_ns": 382975, + "success": true + }, + { + "mutex_wait_ns": 70, + "serialization_ns": 3697, + "serialized_bytes": 611, + "statement_ns": 358229, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3446, + "serialized_bytes": 1036, + "statement_ns": 334384, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3497, + "serialized_bytes": 1075, + "statement_ns": 320267, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3687, + "serialized_bytes": 1083, + "statement_ns": 361204, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3968, + "serialized_bytes": 1298, + "statement_ns": 334373, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1954, + "serialized_bytes": 611, + "statement_ns": 335265, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2746, + "serialized_bytes": 611, + "statement_ns": 290211, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3215, + "serialized_bytes": 1036, + "statement_ns": 324686, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3417, + "serialized_bytes": 1075, + "statement_ns": 323653, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3657, + "serialized_bytes": 1083, + "statement_ns": 302785, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3767, + "serialized_bytes": 1298, + "statement_ns": 313725, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2144, + "serialized_bytes": 613, + "statement_ns": 343601, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2504, + "serialized_bytes": 613, + "statement_ns": 302024, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3256, + "serialized_bytes": 1040, + "statement_ns": 300190, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3587, + "serialized_bytes": 1079, + "statement_ns": 294399, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3777, + "serialized_bytes": 1087, + "statement_ns": 389680, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5250, + "serialized_bytes": 1302, + "statement_ns": 345905, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2374, + "serialized_bytes": 613, + "statement_ns": 345444, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2755, + "serialized_bytes": 613, + "statement_ns": 294449, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3636, + "serialized_bytes": 1040, + "statement_ns": 283609, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3767, + "serialized_bytes": 1079, + "statement_ns": 305349, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3947, + "serialized_bytes": 1087, + "statement_ns": 299930, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4148, + "serialized_bytes": 1302, + "statement_ns": 275183, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1994, + "serialized_bytes": 613, + "statement_ns": 303055, + "success": true + }, + { + "mutex_wait_ns": 60, + "serialization_ns": 23854, + "serialized_bytes": 613, + "statement_ns": 311972, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3196, + "serialized_bytes": 1040, + "statement_ns": 279201, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3486, + "serialized_bytes": 1079, + "statement_ns": 279141, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3606, + "serialized_bytes": 1087, + "statement_ns": 337679, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3857, + "serialized_bytes": 1302, + "statement_ns": 320488, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 2034, + "serialized_bytes": 611, + "statement_ns": 307183, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2375, + "serialized_bytes": 611, + "statement_ns": 336357, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3377, + "serialized_bytes": 1036, + "statement_ns": 279671, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3576, + "serialized_bytes": 1075, + "statement_ns": 276386, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3687, + "serialized_bytes": 1083, + "statement_ns": 311000, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3977, + "serialized_bytes": 1298, + "statement_ns": 278019, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2044, + "serialized_bytes": 613, + "statement_ns": 293668, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2615, + "serialized_bytes": 613, + "statement_ns": 283790, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3266, + "serialized_bytes": 1040, + "statement_ns": 276947, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3446, + "serialized_bytes": 1079, + "statement_ns": 275384, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3526, + "serialized_bytes": 1087, + "statement_ns": 287787, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4028, + "serialized_bytes": 1302, + "statement_ns": 355392, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1984, + "serialized_bytes": 613, + "statement_ns": 2825530, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2485, + "serialized_bytes": 613, + "statement_ns": 1432722, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3246, + "serialized_bytes": 1040, + "statement_ns": 339212, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3457, + "serialized_bytes": 1079, + "statement_ns": 394125, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3637, + "serialized_bytes": 1087, + "statement_ns": 310018, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4027, + "serialized_bytes": 1302, + "statement_ns": 314307, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2154, + "serialized_bytes": 613, + "statement_ns": 340936, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2635, + "serialized_bytes": 613, + "statement_ns": 269352, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3286, + "serialized_bytes": 1040, + "statement_ns": 330075, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3487, + "serialized_bytes": 1079, + "statement_ns": 296072, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3747, + "serialized_bytes": 1087, + "statement_ns": 306602, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3727, + "serialized_bytes": 1302, + "statement_ns": 429792, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2023, + "serialized_bytes": 613, + "statement_ns": 372074, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2515, + "serialized_bytes": 613, + "statement_ns": 311411, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3296, + "serialized_bytes": 1040, + "statement_ns": 350504, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3496, + "serialized_bytes": 1079, + "statement_ns": 304988, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3597, + "serialized_bytes": 1087, + "statement_ns": 341336, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3887, + "serialized_bytes": 1302, + "statement_ns": 344883, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 2083, + "serialized_bytes": 613, + "statement_ns": 339423, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2585, + "serialized_bytes": 613, + "statement_ns": 317131, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3176, + "serialized_bytes": 1040, + "statement_ns": 391780, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3436, + "serialized_bytes": 1079, + "statement_ns": 348309, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3997, + "serialized_bytes": 1087, + "statement_ns": 385830, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3908, + "serialized_bytes": 1302, + "statement_ns": 389326, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2154, + "serialized_bytes": 613, + "statement_ns": 349041, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2485, + "serialized_bytes": 613, + "statement_ns": 329084, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3287, + "serialized_bytes": 1040, + "statement_ns": 333902, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3427, + "serialized_bytes": 1079, + "statement_ns": 309587, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3537, + "serialized_bytes": 1087, + "statement_ns": 321519, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3998, + "serialized_bytes": 1302, + "statement_ns": 324425, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2064, + "serialized_bytes": 611, + "statement_ns": 372805, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2444, + "serialized_bytes": 611, + "statement_ns": 351255, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3236, + "serialized_bytes": 1036, + "statement_ns": 309667, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3396, + "serialized_bytes": 1075, + "statement_ns": 314547, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3526, + "serialized_bytes": 1083, + "statement_ns": 499081, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3767, + "serialized_bytes": 1298, + "statement_ns": 439671, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 2014, + "serialized_bytes": 611, + "statement_ns": 404955, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2614, + "serialized_bytes": 611, + "statement_ns": 315578, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3407, + "serialized_bytes": 1036, + "statement_ns": 371162, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3417, + "serialized_bytes": 1075, + "statement_ns": 345344, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3436, + "serialized_bytes": 1083, + "statement_ns": 346206, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3787, + "serialized_bytes": 1298, + "statement_ns": 400557, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2024, + "serialized_bytes": 613, + "statement_ns": 359721, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2545, + "serialized_bytes": 613, + "statement_ns": 320868, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3115, + "serialized_bytes": 1040, + "statement_ns": 348480, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3416, + "serialized_bytes": 1079, + "statement_ns": 352287, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3487, + "serialized_bytes": 1087, + "statement_ns": 383335, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3857, + "serialized_bytes": 1302, + "statement_ns": 355663, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2004, + "serialized_bytes": 613, + "statement_ns": 347808, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2495, + "serialized_bytes": 613, + "statement_ns": 410996, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3206, + "serialized_bytes": 1040, + "statement_ns": 340415, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3447, + "serialized_bytes": 1079, + "statement_ns": 315879, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3767, + "serialized_bytes": 1087, + "statement_ns": 349762, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4068, + "serialized_bytes": 1302, + "statement_ns": 321079, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 1883, + "serialized_bytes": 611, + "statement_ns": 364510, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2455, + "serialized_bytes": 611, + "statement_ns": 346136, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3256, + "serialized_bytes": 1036, + "statement_ns": 314447, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3386, + "serialized_bytes": 1075, + "statement_ns": 357885, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 6061, + "serialized_bytes": 1083, + "statement_ns": 402481, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 6152, + "serialized_bytes": 1298, + "statement_ns": 417178, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2155, + "serialized_bytes": 611, + "statement_ns": 375710, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2515, + "serialized_bytes": 611, + "statement_ns": 307924, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3166, + "serialized_bytes": 1036, + "statement_ns": 346897, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3386, + "serialized_bytes": 1075, + "statement_ns": 339013, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3487, + "serialized_bytes": 1083, + "statement_ns": 300110, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3777, + "serialized_bytes": 1298, + "statement_ns": 356515, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2184, + "serialized_bytes": 613, + "statement_ns": 372826, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2605, + "serialized_bytes": 613, + "statement_ns": 297475, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3237, + "serialized_bytes": 1040, + "statement_ns": 327171, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3497, + "serialized_bytes": 1079, + "statement_ns": 317893, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3757, + "serialized_bytes": 1087, + "statement_ns": 314226, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3727, + "serialized_bytes": 1302, + "statement_ns": 371102, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 1993, + "serialized_bytes": 613, + "statement_ns": 346397, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2505, + "serialized_bytes": 613, + "statement_ns": 309026, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3186, + "serialized_bytes": 1040, + "statement_ns": 346726, + "success": true + }, + { + "mutex_wait_ns": 70, + "serialization_ns": 5249, + "serialized_bytes": 1079, + "statement_ns": 338091, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5540, + "serialized_bytes": 1087, + "statement_ns": 322943, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5962, + "serialized_bytes": 1302, + "statement_ns": 345654, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 2234, + "serialized_bytes": 611, + "statement_ns": 404444, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3897, + "serialized_bytes": 611, + "statement_ns": 399315, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 4969, + "serialized_bytes": 1036, + "statement_ns": 361614, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 5210, + "serialized_bytes": 1075, + "statement_ns": 318253, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 5210, + "serialized_bytes": 1083, + "statement_ns": 363999, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 5510, + "serialized_bytes": 1298, + "statement_ns": 380951, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 1944, + "serialized_bytes": 613, + "statement_ns": 360863, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 3877, + "serialized_bytes": 613, + "statement_ns": 330888, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4879, + "serialized_bytes": 1040, + "statement_ns": 333803, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 9417, + "serialized_bytes": 1079, + "statement_ns": 399766, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5640, + "serialized_bytes": 1087, + "statement_ns": 370361, + "success": true + }, + { + "mutex_wait_ns": 70, + "serialization_ns": 6021, + "serialized_bytes": 1302, + "statement_ns": 342208, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2274, + "serialized_bytes": 613, + "statement_ns": 368297, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3606, + "serialized_bytes": 613, + "statement_ns": 322762, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 4589, + "serialized_bytes": 1040, + "statement_ns": 365762, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3647, + "serialized_bytes": 1079, + "statement_ns": 366944, + "success": true + }, + { + "mutex_wait_ns": 61, + "serialization_ns": 5510, + "serialized_bytes": 1087, + "statement_ns": 335595, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5891, + "serialized_bytes": 1302, + "statement_ns": 395929, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 2194, + "serialized_bytes": 613, + "statement_ns": 369669, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3526, + "serialized_bytes": 613, + "statement_ns": 352488, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4488, + "serialized_bytes": 1040, + "statement_ns": 344452, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5099, + "serialized_bytes": 1079, + "statement_ns": 381992, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5420, + "serialized_bytes": 1087, + "statement_ns": 377524, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 5510, + "serialized_bytes": 1302, + "statement_ns": 326739, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2254, + "serialized_bytes": 613, + "statement_ns": 345694, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3898, + "serialized_bytes": 613, + "statement_ns": 361033, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4589, + "serialized_bytes": 1040, + "statement_ns": 338882, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5089, + "serialized_bytes": 1079, + "statement_ns": 354301, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5120, + "serialized_bytes": 1087, + "statement_ns": 333081, + "success": true + }, + { + "mutex_wait_ns": 60, + "serialization_ns": 5991, + "serialized_bytes": 1302, + "statement_ns": 352387, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2044, + "serialized_bytes": 611, + "statement_ns": 361414, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3917, + "serialized_bytes": 611, + "statement_ns": 311761, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4789, + "serialized_bytes": 1036, + "statement_ns": 330086, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5230, + "serialized_bytes": 1075, + "statement_ns": 345785, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5340, + "serialized_bytes": 1083, + "statement_ns": 337510, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 10831, + "serialized_bytes": 1298, + "statement_ns": 362125, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 585312, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=1", + "COMPILER=gcc-11.4.0", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_PTHREADS", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "TLS", + "wall_budget_exceeded": false + } + ], + "not_run": { + "disk_flush_count": "not observed", + "gui_android": "outside harness", + "production_performance": "synthetic test-only harness", + "queue_wait": "no writer queue exists", + "sqlite_busy_wait_separate": "included in statement elapsed" + }, + "profile": "release", + "runtime": "current_thread", + "schema": 1, + "status": "PASS", + "timer_network_positive_control": { + "detector_threshold_ms": 100, + "injected_block_ms": 300, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 292052141, + 200494, + 164927 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 292052141, + "end_ns": 303262825, + "in_window": true, + "scheduled_ns": null, + "start_ns": 11210684, + "success": true + }, + { + "elapsed_ns": 200494, + "end_ns": 313569447, + "in_window": false, + "scheduled_ns": null, + "start_ns": 313368953, + "success": true + }, + { + "elapsed_ns": 164927, + "end_ns": 323808683, + "in_window": false, + "scheduled_ns": null, + "start_ns": 323643756, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 290264416, + 617245, + 746586 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 29, + "samples": [ + { + "elapsed_ns": 290264416, + "end_ns": 303212585, + "in_window": true, + "scheduled_ns": 12948169, + "start_ns": 303212585, + "success": true + }, + { + "elapsed_ns": 617245, + "end_ns": 313565414, + "in_window": false, + "scheduled_ns": 312948169, + "start_ns": 313565414, + "success": true + }, + { + "elapsed_ns": 746586, + "end_ns": 323694755, + "in_window": false, + "scheduled_ns": 322948169, + "start_ns": 323694755, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 303067725, + "window_start_ns": 2952306 + }, + "status": "PASS" + }, + "workers": 0 + }, + "cleanup_uncertain": false + }, + { + "profile": "release", + "workers": 2, + "status": "PASS", + "reason": null, + "report": { + "cases": [ + { + "batch_elapsed_ns": 72542836, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 70877006, + 71660848, + 70243705, + 71808940, + 71104787, + 71730544, + 71766975, + 71083698, + 71733673, + 71129917, + 71805053, + 71111440, + 71738883, + 71146568, + 71789695, + 71117270, + 71769350, + 71172768, + 71824049, + 71166783, + 71827919, + 71218032, + 71882408, + 71184766, + 71065486, + 71851356, + 71777705, + 71225018, + 71109769, + 71884634, + 71814511, + 71037204 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 63886992, + 165188, + 135583 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 63886992, + "end_ns": 74256582, + "in_window": true, + "scheduled_ns": null, + "start_ns": 10369590, + "success": true + }, + { + "elapsed_ns": 165188, + "end_ns": 84496901, + "in_window": false, + "scheduled_ns": null, + "start_ns": 84331713, + "success": true + }, + { + "elapsed_ns": 135583, + "end_ns": 94703327, + "in_window": false, + "scheduled_ns": null, + "start_ns": 94567744, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 14796667, + 42080811, + 1628200, + 1180737, + 1439219 + ], + "failures": 0, + "in_window_samples": 2, + "missed_periods": 5, + "samples": [ + { + "elapsed_ns": 14796667, + "end_ns": 27198873, + "in_window": true, + "scheduled_ns": 12402206, + "start_ns": 27198873, + "success": true + }, + { + "elapsed_ns": 42080811, + "end_ns": 74483017, + "in_window": true, + "scheduled_ns": 32402206, + "start_ns": 74483017, + "success": true + }, + { + "elapsed_ns": 1628200, + "end_ns": 84030406, + "in_window": false, + "scheduled_ns": 82402206, + "start_ns": 84030406, + "success": true + }, + { + "elapsed_ns": 1180737, + "end_ns": 93582943, + "in_window": false, + "scheduled_ns": 92402206, + "start_ns": 93582943, + "success": true + }, + { + "elapsed_ns": 1439219, + "end_ns": 103841425, + "in_window": false, + "scheduled_ns": 102402206, + "start_ns": 103841425, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 74958752, + "window_start_ns": 2415916 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 0, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 40, + "serialization_ns": 37510, + "serialized_bytes": 612, + "statement_ns": 467716, + "success": true + }, + { + "mutex_wait_ns": 101747, + "serialization_ns": 2124, + "serialized_bytes": 612, + "statement_ns": 361928, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3587, + "serialized_bytes": 612, + "statement_ns": 296873, + "success": true + }, + { + "mutex_wait_ns": 675938, + "serialization_ns": 3246, + "serialized_bytes": 612, + "statement_ns": 340157, + "success": true + }, + { + "mutex_wait_ns": 348346, + "serialization_ns": 5310, + "serialized_bytes": 1038, + "statement_ns": 317736, + "success": true + }, + { + "mutex_wait_ns": 327207, + "serialization_ns": 4609, + "serialized_bytes": 1038, + "statement_ns": 295254, + "success": true + }, + { + "mutex_wait_ns": 298403, + "serialization_ns": 4940, + "serialized_bytes": 1077, + "statement_ns": 333685, + "success": true + }, + { + "mutex_wait_ns": 340652, + "serialization_ns": 4959, + "serialized_bytes": 1077, + "statement_ns": 353573, + "success": true + }, + { + "mutex_wait_ns": 363965, + "serialization_ns": 5831, + "serialized_bytes": 1085, + "statement_ns": 323006, + "success": true + }, + { + "mutex_wait_ns": 334741, + "serialization_ns": 5471, + "serialized_bytes": 1085, + "statement_ns": 405429, + "success": true + }, + { + "mutex_wait_ns": 412346, + "serialization_ns": 5750, + "serialized_bytes": 1300, + "statement_ns": 319059, + "success": true + }, + { + "mutex_wait_ns": 326386, + "serialization_ns": 6041, + "serialized_bytes": 1300, + "statement_ns": 352801, + "success": true + }, + { + "mutex_wait_ns": 258639, + "serialization_ns": 3236, + "serialized_bytes": 610, + "statement_ns": 430366, + "success": true + }, + { + "mutex_wait_ns": 70, + "serialization_ns": 3436, + "serialized_bytes": 610, + "statement_ns": 337199, + "success": true + }, + { + "mutex_wait_ns": 711985, + "serialization_ns": 6232, + "serialized_bytes": 612, + "statement_ns": 410368, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3827, + "serialized_bytes": 612, + "statement_ns": 306552, + "success": true + }, + { + "mutex_wait_ns": 737944, + "serialization_ns": 4638, + "serialized_bytes": 1034, + "statement_ns": 291046, + "success": true + }, + { + "mutex_wait_ns": 300658, + "serialization_ns": 4629, + "serialized_bytes": 1038, + "statement_ns": 327423, + "success": true + }, + { + "mutex_wait_ns": 333730, + "serialization_ns": 4959, + "serialized_bytes": 1073, + "statement_ns": 294382, + "success": true + }, + { + "mutex_wait_ns": 300948, + "serialization_ns": 5030, + "serialized_bytes": 1077, + "statement_ns": 283221, + "success": true + }, + { + "mutex_wait_ns": 294726, + "serialization_ns": 4799, + "serialized_bytes": 1081, + "statement_ns": 293090, + "success": true + }, + { + "mutex_wait_ns": 304815, + "serialization_ns": 5360, + "serialized_bytes": 1085, + "statement_ns": 509143, + "success": true + }, + { + "mutex_wait_ns": 497715, + "serialization_ns": 25087, + "serialized_bytes": 1296, + "statement_ns": 467635, + "success": true + }, + { + "mutex_wait_ns": 475143, + "serialization_ns": 5741, + "serialized_bytes": 1300, + "statement_ns": 365334, + "success": true + }, + { + "mutex_wait_ns": 274128, + "serialization_ns": 2745, + "serialized_bytes": 612, + "statement_ns": 348513, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2815, + "serialized_bytes": 612, + "statement_ns": 333973, + "success": true + }, + { + "mutex_wait_ns": 624732, + "serialization_ns": 3116, + "serialized_bytes": 612, + "statement_ns": 344626, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3577, + "serialized_bytes": 612, + "statement_ns": 297966, + "success": true + }, + { + "mutex_wait_ns": 663815, + "serialization_ns": 4328, + "serialized_bytes": 1038, + "statement_ns": 314740, + "success": true + }, + { + "mutex_wait_ns": 326606, + "serialization_ns": 4518, + "serialized_bytes": 1038, + "statement_ns": 298159, + "success": true + }, + { + "mutex_wait_ns": 306088, + "serialization_ns": 4739, + "serialized_bytes": 1077, + "statement_ns": 295534, + "success": true + }, + { + "mutex_wait_ns": 301760, + "serialization_ns": 5350, + "serialized_bytes": 1077, + "statement_ns": 293410, + "success": true + }, + { + "mutex_wait_ns": 323931, + "serialization_ns": 4799, + "serialized_bytes": 1085, + "statement_ns": 357166, + "success": true + }, + { + "mutex_wait_ns": 365070, + "serialization_ns": 5601, + "serialized_bytes": 1085, + "statement_ns": 363274, + "success": true + }, + { + "mutex_wait_ns": 370293, + "serialization_ns": 5150, + "serialized_bytes": 1300, + "statement_ns": 461017, + "success": true + }, + { + "mutex_wait_ns": 468877, + "serialization_ns": 5521, + "serialized_bytes": 1300, + "statement_ns": 344610, + "success": true + }, + { + "mutex_wait_ns": 274144, + "serialization_ns": 2695, + "serialized_bytes": 610, + "statement_ns": 458071, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3927, + "serialized_bytes": 610, + "statement_ns": 361244, + "success": true + }, + { + "mutex_wait_ns": 760321, + "serialization_ns": 2605, + "serialized_bytes": 610, + "statement_ns": 401957, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4198, + "serialized_bytes": 610, + "statement_ns": 417128, + "success": true + }, + { + "mutex_wait_ns": 842134, + "serialization_ns": 5270, + "serialized_bytes": 1034, + "statement_ns": 326495, + "success": true + }, + { + "mutex_wait_ns": 337423, + "serialization_ns": 4308, + "serialized_bytes": 1034, + "statement_ns": 345220, + "success": true + }, + { + "mutex_wait_ns": 369793, + "serialization_ns": 5170, + "serialized_bytes": 1073, + "statement_ns": 330503, + "success": true + }, + { + "mutex_wait_ns": 337222, + "serialization_ns": 5150, + "serialized_bytes": 1073, + "statement_ns": 341113, + "success": true + }, + { + "mutex_wait_ns": 353062, + "serialization_ns": 4688, + "serialized_bytes": 1081, + "statement_ns": 378884, + "success": true + }, + { + "mutex_wait_ns": 394469, + "serialization_ns": 5330, + "serialized_bytes": 1081, + "statement_ns": 320895, + "success": true + }, + { + "mutex_wait_ns": 327935, + "serialization_ns": 6121, + "serialized_bytes": 1296, + "statement_ns": 375718, + "success": true + }, + { + "mutex_wait_ns": 383058, + "serialization_ns": 5319, + "serialized_bytes": 1296, + "statement_ns": 382140, + "success": true + }, + { + "mutex_wait_ns": 293430, + "serialization_ns": 2946, + "serialized_bytes": 612, + "statement_ns": 356993, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5029, + "serialized_bytes": 612, + "statement_ns": 292386, + "success": true + }, + { + "mutex_wait_ns": 578162, + "serialization_ns": 3056, + "serialized_bytes": 612, + "statement_ns": 427323, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3827, + "serialized_bytes": 612, + "statement_ns": 301302, + "success": true + }, + { + "mutex_wait_ns": 751145, + "serialization_ns": 5009, + "serialized_bytes": 1038, + "statement_ns": 331484, + "success": true + }, + { + "mutex_wait_ns": 359204, + "serialization_ns": 4718, + "serialized_bytes": 1038, + "statement_ns": 332476, + "success": true + }, + { + "mutex_wait_ns": 335539, + "serialization_ns": 4789, + "serialized_bytes": 1077, + "statement_ns": 312559, + "success": true + }, + { + "mutex_wait_ns": 322795, + "serialization_ns": 5250, + "serialized_bytes": 1077, + "statement_ns": 328559, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5691, + "serialized_bytes": 1085, + "statement_ns": 315779, + "success": true + }, + { + "mutex_wait_ns": 670604, + "serialization_ns": 5621, + "serialized_bytes": 1085, + "statement_ns": 305947, + "success": true + }, + { + "mutex_wait_ns": 312997, + "serialization_ns": 5710, + "serialized_bytes": 1300, + "statement_ns": 330433, + "success": true + }, + { + "mutex_wait_ns": 347351, + "serialization_ns": 5791, + "serialized_bytes": 1300, + "statement_ns": 367763, + "success": true + }, + { + "mutex_wait_ns": 297447, + "serialization_ns": 3347, + "serialized_bytes": 612, + "statement_ns": 349379, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3166, + "serialized_bytes": 612, + "statement_ns": 301332, + "success": true + }, + { + "mutex_wait_ns": 566250, + "serialization_ns": 2725, + "serialized_bytes": 612, + "statement_ns": 346823, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3246, + "serialized_bytes": 612, + "statement_ns": 279180, + "success": true + }, + { + "mutex_wait_ns": 645016, + "serialization_ns": 4729, + "serialized_bytes": 1038, + "statement_ns": 550594, + "success": true + }, + { + "mutex_wait_ns": 560438, + "serialization_ns": 4408, + "serialized_bytes": 1038, + "statement_ns": 404972, + "success": true + }, + { + "mutex_wait_ns": 411110, + "serialization_ns": 4980, + "serialized_bytes": 1077, + "statement_ns": 333859, + "success": true + }, + { + "mutex_wait_ns": 341530, + "serialization_ns": 4869, + "serialized_bytes": 1077, + "statement_ns": 314884, + "success": true + }, + { + "mutex_wait_ns": 326733, + "serialization_ns": 5330, + "serialized_bytes": 1085, + "statement_ns": 305596, + "success": true + }, + { + "mutex_wait_ns": 318167, + "serialization_ns": 4989, + "serialized_bytes": 1085, + "statement_ns": 335162, + "success": true + }, + { + "mutex_wait_ns": 343193, + "serialization_ns": 5260, + "serialized_bytes": 1300, + "statement_ns": 346082, + "success": true + }, + { + "mutex_wait_ns": 353623, + "serialization_ns": 5741, + "serialized_bytes": 1300, + "statement_ns": 327467, + "success": true + }, + { + "mutex_wait_ns": 249329, + "serialization_ns": 3055, + "serialized_bytes": 612, + "statement_ns": 395544, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 3267, + "serialized_bytes": 612, + "statement_ns": 299608, + "success": true + }, + { + "mutex_wait_ns": 618097, + "serialization_ns": 3767, + "serialized_bytes": 612, + "statement_ns": 356010, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3347, + "serialized_bytes": 612, + "statement_ns": 377644, + "success": true + }, + { + "mutex_wait_ns": 753559, + "serialization_ns": 4539, + "serialized_bytes": 1038, + "statement_ns": 328168, + "success": true + }, + { + "mutex_wait_ns": 337613, + "serialization_ns": 4588, + "serialized_bytes": 1038, + "statement_ns": 311568, + "success": true + }, + { + "mutex_wait_ns": 316944, + "serialization_ns": 5811, + "serialized_bytes": 1077, + "statement_ns": 386949, + "success": true + }, + { + "mutex_wait_ns": 394288, + "serialization_ns": 5070, + "serialized_bytes": 1077, + "statement_ns": 302441, + "success": true + }, + { + "mutex_wait_ns": 314069, + "serialization_ns": 5149, + "serialized_bytes": 1085, + "statement_ns": 394182, + "success": true + }, + { + "mutex_wait_ns": 405881, + "serialization_ns": 4939, + "serialized_bytes": 1085, + "statement_ns": 322187, + "success": true + }, + { + "mutex_wait_ns": 328917, + "serialization_ns": 5329, + "serialized_bytes": 1300, + "statement_ns": 376990, + "success": true + }, + { + "mutex_wait_ns": 384030, + "serialization_ns": 5399, + "serialized_bytes": 1300, + "statement_ns": 385185, + "success": true + }, + { + "mutex_wait_ns": 315882, + "serialization_ns": 2895, + "serialized_bytes": 612, + "statement_ns": 407447, + "success": true + }, + { + "mutex_wait_ns": 60, + "serialization_ns": 3186, + "serialized_bytes": 612, + "statement_ns": 320318, + "success": true + }, + { + "mutex_wait_ns": 656087, + "serialization_ns": 2685, + "serialized_bytes": 612, + "statement_ns": 417145, + "success": true + }, + { + "mutex_wait_ns": 60, + "serialization_ns": 3387, + "serialized_bytes": 612, + "statement_ns": 326960, + "success": true + }, + { + "mutex_wait_ns": 765641, + "serialization_ns": 4619, + "serialized_bytes": 1038, + "statement_ns": 375788, + "success": true + }, + { + "mutex_wait_ns": 385302, + "serialization_ns": 4478, + "serialized_bytes": 1038, + "statement_ns": 372712, + "success": true + }, + { + "mutex_wait_ns": 379021, + "serialization_ns": 5339, + "serialized_bytes": 1077, + "statement_ns": 311858, + "success": true + }, + { + "mutex_wait_ns": 319048, + "serialization_ns": 4779, + "serialized_bytes": 1077, + "statement_ns": 332116, + "success": true + }, + { + "mutex_wait_ns": 343624, + "serialization_ns": 5240, + "serialized_bytes": 1085, + "statement_ns": 309164, + "success": true + }, + { + "mutex_wait_ns": 320692, + "serialization_ns": 5179, + "serialized_bytes": 1085, + "statement_ns": 312329, + "success": true + }, + { + "mutex_wait_ns": 320000, + "serialization_ns": 5390, + "serialized_bytes": 1300, + "statement_ns": 402848, + "success": true + }, + { + "mutex_wait_ns": 411210, + "serialization_ns": 5530, + "serialized_bytes": 1300, + "statement_ns": 394994, + "success": true + }, + { + "mutex_wait_ns": 325601, + "serialization_ns": 2845, + "serialized_bytes": 612, + "statement_ns": 445046, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 3236, + "serialized_bytes": 612, + "statement_ns": 348340, + "success": true + }, + { + "mutex_wait_ns": 725426, + "serialization_ns": 2795, + "serialized_bytes": 610, + "statement_ns": 368364, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3336, + "serialized_bytes": 610, + "statement_ns": 299429, + "success": true + }, + { + "mutex_wait_ns": 689800, + "serialization_ns": 4147, + "serialized_bytes": 1038, + "statement_ns": 306228, + "success": true + }, + { + "mutex_wait_ns": 316063, + "serialization_ns": 4688, + "serialized_bytes": 1034, + "statement_ns": 300177, + "success": true + }, + { + "mutex_wait_ns": 306435, + "serialization_ns": 4739, + "serialized_bytes": 1077, + "statement_ns": 339981, + "success": true + }, + { + "mutex_wait_ns": 347481, + "serialization_ns": 5050, + "serialized_bytes": 1073, + "statement_ns": 320955, + "success": true + }, + { + "mutex_wait_ns": 332704, + "serialization_ns": 4999, + "serialized_bytes": 1085, + "statement_ns": 290348, + "success": true + }, + { + "mutex_wait_ns": 302197, + "serialization_ns": 4869, + "serialized_bytes": 1081, + "statement_ns": 324572, + "success": true + }, + { + "mutex_wait_ns": 332974, + "serialization_ns": 5229, + "serialized_bytes": 1300, + "statement_ns": 354088, + "success": true + }, + { + "mutex_wait_ns": 361978, + "serialization_ns": 5490, + "serialized_bytes": 1296, + "statement_ns": 390726, + "success": true + }, + { + "mutex_wait_ns": 320491, + "serialization_ns": 2685, + "serialized_bytes": 612, + "statement_ns": 421823, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3126, + "serialized_bytes": 612, + "statement_ns": 371683, + "success": true + }, + { + "mutex_wait_ns": 721649, + "serialization_ns": 2836, + "serialized_bytes": 612, + "statement_ns": 403519, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3547, + "serialized_bytes": 612, + "statement_ns": 358148, + "success": true + }, + { + "mutex_wait_ns": 782814, + "serialization_ns": 4248, + "serialized_bytes": 1038, + "statement_ns": 357303, + "success": true + }, + { + "mutex_wait_ns": 367028, + "serialization_ns": 4518, + "serialized_bytes": 1038, + "statement_ns": 394452, + "success": true + }, + { + "mutex_wait_ns": 401593, + "serialization_ns": 4708, + "serialized_bytes": 1077, + "statement_ns": 330994, + "success": true + }, + { + "mutex_wait_ns": 337853, + "serialization_ns": 4919, + "serialized_bytes": 1077, + "statement_ns": 344540, + "success": true + }, + { + "mutex_wait_ns": 355646, + "serialization_ns": 5000, + "serialized_bytes": 1085, + "statement_ns": 347786, + "success": true + }, + { + "mutex_wait_ns": 359874, + "serialization_ns": 5110, + "serialized_bytes": 1085, + "statement_ns": 325344, + "success": true + }, + { + "mutex_wait_ns": 333625, + "serialization_ns": 5380, + "serialized_bytes": 1300, + "statement_ns": 351443, + "success": true + }, + { + "mutex_wait_ns": 358912, + "serialization_ns": 5461, + "serialized_bytes": 1300, + "statement_ns": 367222, + "success": true + }, + { + "mutex_wait_ns": 277191, + "serialization_ns": 2895, + "serialized_bytes": 612, + "statement_ns": 353987, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3096, + "serialized_bytes": 612, + "statement_ns": 328633, + "success": true + }, + { + "mutex_wait_ns": 614640, + "serialization_ns": 2946, + "serialized_bytes": 610, + "statement_ns": 352283, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3576, + "serialized_bytes": 610, + "statement_ns": 290072, + "success": true + }, + { + "mutex_wait_ns": 662789, + "serialization_ns": 4649, + "serialized_bytes": 1038, + "statement_ns": 320053, + "success": true + }, + { + "mutex_wait_ns": 330109, + "serialization_ns": 4949, + "serialized_bytes": 1034, + "statement_ns": 321957, + "success": true + }, + { + "mutex_wait_ns": 329007, + "serialization_ns": 4899, + "serialized_bytes": 1077, + "statement_ns": 335843, + "success": true + }, + { + "mutex_wait_ns": 342101, + "serialization_ns": 5140, + "serialized_bytes": 1073, + "statement_ns": 303553, + "success": true + }, + { + "mutex_wait_ns": 317406, + "serialization_ns": 4818, + "serialized_bytes": 1085, + "statement_ns": 322458, + "success": true + }, + { + "mutex_wait_ns": 333836, + "serialization_ns": 5259, + "serialized_bytes": 1081, + "statement_ns": 317619, + "success": true + }, + { + "mutex_wait_ns": 312265, + "serialization_ns": 6142, + "serialized_bytes": 1300, + "statement_ns": 370939, + "success": true + }, + { + "mutex_wait_ns": 379541, + "serialization_ns": 5310, + "serialized_bytes": 1296, + "statement_ns": 355129, + "success": true + }, + { + "mutex_wait_ns": 274205, + "serialization_ns": 3116, + "serialized_bytes": 612, + "statement_ns": 346773, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 3497, + "serialized_bytes": 612, + "statement_ns": 361283, + "success": true + }, + { + "mutex_wait_ns": 634587, + "serialization_ns": 2906, + "serialized_bytes": 610, + "statement_ns": 337085, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3427, + "serialized_bytes": 610, + "statement_ns": 284501, + "success": true + }, + { + "mutex_wait_ns": 642321, + "serialization_ns": 4559, + "serialized_bytes": 1038, + "statement_ns": 320985, + "success": true + }, + { + "mutex_wait_ns": 331552, + "serialization_ns": 4639, + "serialized_bytes": 1034, + "statement_ns": 312639, + "success": true + }, + { + "mutex_wait_ns": 319058, + "serialization_ns": 4909, + "serialized_bytes": 1077, + "statement_ns": 293354, + "success": true + }, + { + "mutex_wait_ns": 300093, + "serialization_ns": 4979, + "serialized_bytes": 1073, + "statement_ns": 333048, + "success": true + }, + { + "mutex_wait_ns": 345026, + "serialization_ns": 5130, + "serialized_bytes": 1085, + "statement_ns": 307671, + "success": true + }, + { + "mutex_wait_ns": 319469, + "serialization_ns": 5170, + "serialized_bytes": 1081, + "statement_ns": 299816, + "success": true + }, + { + "mutex_wait_ns": 307487, + "serialization_ns": 5500, + "serialized_bytes": 1300, + "statement_ns": 352665, + "success": true + }, + { + "mutex_wait_ns": 361317, + "serialization_ns": 5170, + "serialized_bytes": 1296, + "statement_ns": 327658, + "success": true + }, + { + "mutex_wait_ns": 253056, + "serialization_ns": 3236, + "serialized_bytes": 612, + "statement_ns": 402557, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 3446, + "serialized_bytes": 612, + "statement_ns": 327251, + "success": true + }, + { + "mutex_wait_ns": 659865, + "serialization_ns": 2945, + "serialized_bytes": 612, + "statement_ns": 333639, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3517, + "serialized_bytes": 612, + "statement_ns": 279852, + "success": true + }, + { + "mutex_wait_ns": 633956, + "serialization_ns": 4568, + "serialized_bytes": 1038, + "statement_ns": 362823, + "success": true + }, + { + "mutex_wait_ns": 373290, + "serialization_ns": 4548, + "serialized_bytes": 1038, + "statement_ns": 294556, + "success": true + }, + { + "mutex_wait_ns": 300824, + "serialization_ns": 5320, + "serialized_bytes": 1077, + "statement_ns": 284748, + "success": true + }, + { + "mutex_wait_ns": 292148, + "serialization_ns": 4849, + "serialized_bytes": 1077, + "statement_ns": 300237, + "success": true + }, + { + "mutex_wait_ns": 313097, + "serialization_ns": 5079, + "serialized_bytes": 1085, + "statement_ns": 350350, + "success": true + }, + { + "mutex_wait_ns": 362058, + "serialization_ns": 5080, + "serialized_bytes": 1085, + "statement_ns": 374786, + "success": true + }, + { + "mutex_wait_ns": 381535, + "serialization_ns": 5279, + "serialized_bytes": 1300, + "statement_ns": 417395, + "success": true + }, + { + "mutex_wait_ns": 425297, + "serialization_ns": 5480, + "serialized_bytes": 1300, + "statement_ns": 342405, + "success": true + }, + { + "mutex_wait_ns": 273343, + "serialization_ns": 3216, + "serialized_bytes": 610, + "statement_ns": 398731, + "success": true + }, + { + "mutex_wait_ns": 70, + "serialization_ns": 3216, + "serialized_bytes": 610, + "statement_ns": 308525, + "success": true + }, + { + "mutex_wait_ns": 572411, + "serialization_ns": 3276, + "serialized_bytes": 610, + "statement_ns": 351462, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3195, + "serialized_bytes": 610, + "statement_ns": 340875, + "success": true + }, + { + "mutex_wait_ns": 712663, + "serialization_ns": 4538, + "serialized_bytes": 1034, + "statement_ns": 310495, + "success": true + }, + { + "mutex_wait_ns": 319549, + "serialization_ns": 4478, + "serialized_bytes": 1034, + "statement_ns": 304716, + "success": true + }, + { + "mutex_wait_ns": 310803, + "serialization_ns": 5140, + "serialized_bytes": 1073, + "statement_ns": 316948, + "success": true + }, + { + "mutex_wait_ns": 325460, + "serialization_ns": 4679, + "serialized_bytes": 1073, + "statement_ns": 310205, + "success": true + }, + { + "mutex_wait_ns": 321903, + "serialization_ns": 5250, + "serialized_bytes": 1081, + "statement_ns": 303623, + "success": true + }, + { + "mutex_wait_ns": 314760, + "serialization_ns": 5020, + "serialized_bytes": 1081, + "statement_ns": 355089, + "success": true + }, + { + "mutex_wait_ns": 363742, + "serialization_ns": 5470, + "serialized_bytes": 1296, + "statement_ns": 403579, + "success": true + }, + { + "mutex_wait_ns": 412042, + "serialization_ns": 5440, + "serialized_bytes": 1296, + "statement_ns": 361671, + "success": true + }, + { + "mutex_wait_ns": 286328, + "serialization_ns": 3115, + "serialized_bytes": 612, + "statement_ns": 442091, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3086, + "serialized_bytes": 612, + "statement_ns": 327601, + "success": true + }, + { + "mutex_wait_ns": 678188, + "serialization_ns": 2765, + "serialized_bytes": 612, + "statement_ns": 398761, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3277, + "serialized_bytes": 612, + "statement_ns": 283538, + "success": true + }, + { + "mutex_wait_ns": 703095, + "serialization_ns": 4589, + "serialized_bytes": 1038, + "statement_ns": 298954, + "success": true + }, + { + "mutex_wait_ns": 308949, + "serialization_ns": 4319, + "serialized_bytes": 1038, + "statement_ns": 343698, + "success": true + }, + { + "mutex_wait_ns": 351288, + "serialization_ns": 4819, + "serialized_bytes": 1077, + "statement_ns": 308924, + "success": true + }, + { + "mutex_wait_ns": 316774, + "serialization_ns": 4879, + "serialized_bytes": 1077, + "statement_ns": 300367, + "success": true + }, + { + "mutex_wait_ns": 311805, + "serialization_ns": 4909, + "serialized_bytes": 1085, + "statement_ns": 326496, + "success": true + }, + { + "mutex_wait_ns": 338785, + "serialization_ns": 5109, + "serialized_bytes": 1085, + "statement_ns": 354077, + "success": true + }, + { + "mutex_wait_ns": 362970, + "serialization_ns": 5370, + "serialized_bytes": 1300, + "statement_ns": 417325, + "success": true + }, + { + "mutex_wait_ns": 425557, + "serialization_ns": 5540, + "serialized_bytes": 1300, + "statement_ns": 384404, + "success": true + }, + { + "mutex_wait_ns": 294392, + "serialization_ns": 25779, + "serialized_bytes": 610, + "statement_ns": 440949, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3135, + "serialized_bytes": 610, + "statement_ns": 316431, + "success": true + }, + { + "mutex_wait_ns": 688928, + "serialization_ns": 2986, + "serialized_bytes": 610, + "statement_ns": 455977, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3726, + "serialized_bytes": 610, + "statement_ns": 412339, + "success": true + }, + { + "mutex_wait_ns": 888684, + "serialization_ns": 4468, + "serialized_bytes": 1034, + "statement_ns": 380890, + "success": true + }, + { + "mutex_wait_ns": 390568, + "serialization_ns": 4539, + "serialized_bytes": 1034, + "statement_ns": 370311, + "success": true + }, + { + "mutex_wait_ns": 379598, + "serialization_ns": 4369, + "serialized_bytes": 1073, + "statement_ns": 378876, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3577, + "serialized_bytes": 1081, + "statement_ns": 342398, + "success": true + }, + { + "mutex_wait_ns": 736564, + "serialization_ns": 4087, + "serialized_bytes": 1073, + "statement_ns": 370531, + "success": true + }, + { + "mutex_wait_ns": 381933, + "serialization_ns": 3626, + "serialized_bytes": 1296, + "statement_ns": 407650, + "success": true + }, + { + "mutex_wait_ns": 418250, + "serialization_ns": 5269, + "serialized_bytes": 1081, + "statement_ns": 352622, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 6111, + "serialized_bytes": 1296, + "statement_ns": 402917, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 1074254, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=1", + "COMPILER=gcc-11.4.0", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_PTHREADS", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "HTTP", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 75018829, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 62110877, + 62633852, + 62261520, + 62679780, + 62284821, + 62663236, + 62345387, + 62761794, + 62403081, + 62799060, + 62472033, + 62845069, + 62476859, + 62837011, + 62509363, + 62862421, + 69853544, + 70217964, + 69892390, + 70249857, + 73881897, + 73567109, + 73898671, + 73582211, + 73891835, + 73572549, + 73901245, + 73584565, + 73549269, + 73573140, + 73548688, + 74183809 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 54745463, + 1708476, + 158866, + 141904 + ], + "failures": 0, + "in_window_samples": 2, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 54745463, + "end_ns": 65059925, + "in_window": true, + "scheduled_ns": null, + "start_ns": 10314462, + "success": true + }, + { + "elapsed_ns": 1708476, + "end_ns": 76842299, + "in_window": true, + "scheduled_ns": null, + "start_ns": 75133823, + "success": true + }, + { + "elapsed_ns": 158866, + "end_ns": 87077128, + "in_window": false, + "scheduled_ns": null, + "start_ns": 86918262, + "success": true + }, + { + "elapsed_ns": 141904, + "end_ns": 97294614, + "in_window": false, + "scheduled_ns": null, + "start_ns": 97152710, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 28506115, + 30460018, + 1094662, + 802146, + 1166466 + ], + "failures": 0, + "in_window_samples": 2, + "missed_periods": 5, + "samples": [ + { + "elapsed_ns": 28506115, + "end_ns": 40863013, + "in_window": true, + "scheduled_ns": 12356898, + "start_ns": 40863013, + "success": true + }, + { + "elapsed_ns": 30460018, + "end_ns": 72816916, + "in_window": true, + "scheduled_ns": 42356898, + "start_ns": 72816916, + "success": true + }, + { + "elapsed_ns": 1094662, + "end_ns": 83451560, + "in_window": false, + "scheduled_ns": 82356898, + "start_ns": 83451560, + "success": true + }, + { + "elapsed_ns": 802146, + "end_ns": 93159044, + "in_window": false, + "scheduled_ns": 92356898, + "start_ns": 93159044, + "success": true + }, + { + "elapsed_ns": 1166466, + "end_ns": 103523364, + "in_window": false, + "scheduled_ns": 102356898, + "start_ns": 103523364, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 77387116, + "window_start_ns": 2368287 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 1, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 40, + "serialization_ns": 2895, + "serialized_bytes": 612, + "statement_ns": 1127383, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2574, + "serialized_bytes": 612, + "statement_ns": 450119, + "success": true + }, + { + "mutex_wait_ns": 1349547, + "serialization_ns": 2404, + "serialized_bytes": 612, + "statement_ns": 469857, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2736, + "serialized_bytes": 612, + "statement_ns": 358839, + "success": true + }, + { + "mutex_wait_ns": 843683, + "serialization_ns": 3717, + "serialized_bytes": 1038, + "statement_ns": 417359, + "success": true + }, + { + "mutex_wait_ns": 424702, + "serialization_ns": 3396, + "serialized_bytes": 1038, + "statement_ns": 395738, + "success": true + }, + { + "mutex_wait_ns": 400207, + "serialization_ns": 3326, + "serialized_bytes": 1077, + "statement_ns": 367195, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3807, + "serialized_bytes": 1085, + "statement_ns": 377524, + "success": true + }, + { + "mutex_wait_ns": 760558, + "serialization_ns": 3357, + "serialized_bytes": 1077, + "statement_ns": 363659, + "success": true + }, + { + "mutex_wait_ns": 370461, + "serialization_ns": 3797, + "serialized_bytes": 1300, + "statement_ns": 383175, + "success": true + }, + { + "mutex_wait_ns": 392933, + "serialization_ns": 3767, + "serialized_bytes": 1085, + "statement_ns": 572347, + "success": true + }, + { + "mutex_wait_ns": 521593, + "serialization_ns": 2254, + "serialized_bytes": 612, + "statement_ns": 381552, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2504, + "serialized_bytes": 612, + "statement_ns": 431044, + "success": true + }, + { + "mutex_wait_ns": 827323, + "serialization_ns": 3737, + "serialized_bytes": 1300, + "statement_ns": 382838, + "success": true + }, + { + "mutex_wait_ns": 395107, + "serialization_ns": 3176, + "serialized_bytes": 1038, + "statement_ns": 371223, + "success": true + }, + { + "mutex_wait_ns": 305690, + "serialization_ns": 2896, + "serialized_bytes": 612, + "statement_ns": 392381, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 3446, + "serialized_bytes": 612, + "statement_ns": 493461, + "success": true + }, + { + "mutex_wait_ns": 904978, + "serialization_ns": 5490, + "serialized_bytes": 1077, + "statement_ns": 390939, + "success": true + }, + { + "mutex_wait_ns": 399725, + "serialization_ns": 4659, + "serialized_bytes": 1038, + "statement_ns": 519159, + "success": true + }, + { + "mutex_wait_ns": 529337, + "serialization_ns": 6112, + "serialized_bytes": 1085, + "statement_ns": 355573, + "success": true + }, + { + "mutex_wait_ns": 362427, + "serialization_ns": 5149, + "serialized_bytes": 1077, + "statement_ns": 317993, + "success": true + }, + { + "mutex_wait_ns": 324475, + "serialization_ns": 6072, + "serialized_bytes": 1300, + "statement_ns": 354090, + "success": true + }, + { + "mutex_wait_ns": 365081, + "serialization_ns": 5721, + "serialized_bytes": 1085, + "statement_ns": 378185, + "success": true + }, + { + "mutex_wait_ns": 314857, + "serialization_ns": 3217, + "serialized_bytes": 612, + "statement_ns": 406748, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3837, + "serialized_bytes": 612, + "statement_ns": 360652, + "success": true + }, + { + "mutex_wait_ns": 786427, + "serialization_ns": 5901, + "serialized_bytes": 1300, + "statement_ns": 321880, + "success": true + }, + { + "mutex_wait_ns": 331809, + "serialization_ns": 4999, + "serialized_bytes": 1038, + "statement_ns": 348971, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 5290, + "serialized_bytes": 1077, + "statement_ns": 330436, + "success": true + }, + { + "mutex_wait_ns": 647978, + "serialization_ns": 2996, + "serialized_bytes": 612, + "statement_ns": 358338, + "success": true + }, + { + "mutex_wait_ns": 71, + "serialization_ns": 3686, + "serialized_bytes": 612, + "statement_ns": 294749, + "success": true + }, + { + "mutex_wait_ns": 698162, + "serialization_ns": 5259, + "serialized_bytes": 1085, + "statement_ns": 334725, + "success": true + }, + { + "mutex_wait_ns": 344532, + "serialization_ns": 4649, + "serialized_bytes": 1038, + "statement_ns": 354792, + "success": true + }, + { + "mutex_wait_ns": 367776, + "serialization_ns": 6091, + "serialized_bytes": 1300, + "statement_ns": 352678, + "success": true + }, + { + "mutex_wait_ns": 364981, + "serialization_ns": 5370, + "serialized_bytes": 1077, + "statement_ns": 339503, + "success": true + }, + { + "mutex_wait_ns": 278700, + "serialization_ns": 2906, + "serialized_bytes": 612, + "statement_ns": 353910, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3637, + "serialized_bytes": 612, + "statement_ns": 274491, + "success": true + }, + { + "mutex_wait_ns": 652547, + "serialization_ns": 4999, + "serialized_bytes": 1085, + "statement_ns": 291283, + "success": true + }, + { + "mutex_wait_ns": 300941, + "serialization_ns": 4869, + "serialized_bytes": 1038, + "statement_ns": 398623, + "success": true + }, + { + "mutex_wait_ns": 407219, + "serialization_ns": 6252, + "serialized_bytes": 1300, + "statement_ns": 394416, + "success": true + }, + { + "mutex_wait_ns": 400567, + "serialization_ns": 5531, + "serialized_bytes": 1077, + "statement_ns": 417358, + "success": true + }, + { + "mutex_wait_ns": 366373, + "serialization_ns": 3085, + "serialized_bytes": 610, + "statement_ns": 387363, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3607, + "serialized_bytes": 610, + "statement_ns": 287316, + "success": true + }, + { + "mutex_wait_ns": 698453, + "serialization_ns": 5551, + "serialized_bytes": 1085, + "statement_ns": 311931, + "success": true + }, + { + "mutex_wait_ns": 341477, + "serialization_ns": 4999, + "serialized_bytes": 1034, + "statement_ns": 396820, + "success": true + }, + { + "mutex_wait_ns": 399625, + "serialization_ns": 6192, + "serialized_bytes": 1300, + "statement_ns": 347598, + "success": true + }, + { + "mutex_wait_ns": 353279, + "serialization_ns": 5710, + "serialized_bytes": 1073, + "statement_ns": 402481, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5991, + "serialized_bytes": 1081, + "statement_ns": 310108, + "success": true + }, + { + "mutex_wait_ns": 665812, + "serialization_ns": 2945, + "serialized_bytes": 612, + "statement_ns": 493500, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3596, + "serialized_bytes": 612, + "statement_ns": 316961, + "success": true + }, + { + "mutex_wait_ns": 830258, + "serialization_ns": 5721, + "serialized_bytes": 1296, + "statement_ns": 296874, + "success": true + }, + { + "mutex_wait_ns": 306131, + "serialization_ns": 4749, + "serialized_bytes": 1038, + "statement_ns": 348800, + "success": true + }, + { + "mutex_wait_ns": 297985, + "serialization_ns": 2816, + "serialized_bytes": 610, + "statement_ns": 370832, + "success": true + }, + { + "mutex_wait_ns": 51, + "serialization_ns": 3767, + "serialized_bytes": 610, + "statement_ns": 279240, + "success": true + }, + { + "mutex_wait_ns": 674268, + "serialization_ns": 5390, + "serialized_bytes": 1077, + "statement_ns": 332981, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 6612, + "serialized_bytes": 1085, + "statement_ns": 312794, + "success": true + }, + { + "mutex_wait_ns": 672173, + "serialization_ns": 4979, + "serialized_bytes": 1034, + "statement_ns": 301573, + "success": true + }, + { + "mutex_wait_ns": 307804, + "serialization_ns": 6342, + "serialized_bytes": 1300, + "statement_ns": 382554, + "success": true + }, + { + "mutex_wait_ns": 395337, + "serialization_ns": 5180, + "serialized_bytes": 1073, + "statement_ns": 329404, + "success": true + }, + { + "mutex_wait_ns": 272027, + "serialization_ns": 3166, + "serialized_bytes": 612, + "statement_ns": 320889, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3256, + "serialized_bytes": 612, + "statement_ns": 374158, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4689, + "serialized_bytes": 1038, + "statement_ns": 317201, + "success": true + }, + { + "mutex_wait_ns": 1051571, + "serialization_ns": 5220, + "serialized_bytes": 1081, + "statement_ns": 298096, + "success": true + }, + { + "mutex_wait_ns": 304679, + "serialization_ns": 5049, + "serialized_bytes": 1077, + "statement_ns": 336457, + "success": true + }, + { + "mutex_wait_ns": 70, + "serialization_ns": 5420, + "serialized_bytes": 1085, + "statement_ns": 324495, + "success": true + }, + { + "mutex_wait_ns": 683064, + "serialization_ns": 5691, + "serialized_bytes": 1296, + "statement_ns": 299649, + "success": true + }, + { + "mutex_wait_ns": 307484, + "serialization_ns": 5319, + "serialized_bytes": 1300, + "statement_ns": 406869, + "success": true + }, + { + "mutex_wait_ns": 361394, + "serialization_ns": 2835, + "serialized_bytes": 610, + "statement_ns": 341648, + "success": true + }, + { + "mutex_wait_ns": 60, + "serialization_ns": 3286, + "serialized_bytes": 610, + "statement_ns": 274452, + "success": true + }, + { + "mutex_wait_ns": 569302, + "serialization_ns": 3296, + "serialized_bytes": 610, + "statement_ns": 397791, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3717, + "serialized_bytes": 610, + "statement_ns": 287106, + "success": true + }, + { + "mutex_wait_ns": 706819, + "serialization_ns": 4759, + "serialized_bytes": 1034, + "statement_ns": 288898, + "success": true + }, + { + "mutex_wait_ns": 298286, + "serialization_ns": 4398, + "serialized_bytes": 1034, + "statement_ns": 359390, + "success": true + }, + { + "mutex_wait_ns": 371473, + "serialization_ns": 5129, + "serialized_bytes": 1073, + "statement_ns": 320047, + "success": true + }, + { + "mutex_wait_ns": 332721, + "serialization_ns": 5059, + "serialized_bytes": 1073, + "statement_ns": 286915, + "success": true + }, + { + "mutex_wait_ns": 298076, + "serialization_ns": 5250, + "serialized_bytes": 1081, + "statement_ns": 322431, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 6322, + "serialized_bytes": 1296, + "statement_ns": 296874, + "success": true + }, + { + "mutex_wait_ns": 650202, + "serialization_ns": 5230, + "serialized_bytes": 1081, + "statement_ns": 302484, + "success": true + }, + { + "mutex_wait_ns": 249545, + "serialization_ns": 3617, + "serialized_bytes": 612, + "statement_ns": 477290, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4017, + "serialized_bytes": 612, + "statement_ns": 331609, + "success": true + }, + { + "mutex_wait_ns": 827824, + "serialization_ns": 5891, + "serialized_bytes": 1296, + "statement_ns": 372004, + "success": true + }, + { + "mutex_wait_ns": 388375, + "serialization_ns": 4879, + "serialized_bytes": 1038, + "statement_ns": 352116, + "success": true + }, + { + "mutex_wait_ns": 306912, + "serialization_ns": 3056, + "serialized_bytes": 610, + "statement_ns": 516002, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3266, + "serialized_bytes": 610, + "statement_ns": 351966, + "success": true + }, + { + "mutex_wait_ns": 907944, + "serialization_ns": 4969, + "serialized_bytes": 1077, + "statement_ns": 287426, + "success": true + }, + { + "mutex_wait_ns": 296794, + "serialization_ns": 4799, + "serialized_bytes": 1034, + "statement_ns": 300110, + "success": true + }, + { + "mutex_wait_ns": 328542, + "serialization_ns": 5541, + "serialized_bytes": 1085, + "statement_ns": 385940, + "success": true + }, + { + "mutex_wait_ns": 386792, + "serialization_ns": 5390, + "serialized_bytes": 1073, + "statement_ns": 309597, + "success": true + }, + { + "mutex_wait_ns": 316631, + "serialization_ns": 5560, + "serialized_bytes": 1300, + "statement_ns": 310619, + "success": true + }, + { + "mutex_wait_ns": 331979, + "serialization_ns": 4959, + "serialized_bytes": 1081, + "statement_ns": 354531, + "success": true + }, + { + "mutex_wait_ns": 298526, + "serialization_ns": 3106, + "serialized_bytes": 612, + "statement_ns": 338923, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3266, + "serialized_bytes": 612, + "statement_ns": 288631, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3446, + "serialized_bytes": 1038, + "statement_ns": 306331, + "success": true + }, + { + "mutex_wait_ns": 961967, + "serialization_ns": 5530, + "serialized_bytes": 1296, + "statement_ns": 389837, + "success": true + }, + { + "mutex_wait_ns": 396700, + "serialization_ns": 3586, + "serialized_bytes": 1077, + "statement_ns": 328943, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3777, + "serialized_bytes": 1085, + "statement_ns": 317482, + "success": true + }, + { + "mutex_wait_ns": 612967, + "serialization_ns": 2454, + "serialized_bytes": 610, + "statement_ns": 333442, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2865, + "serialized_bytes": 610, + "statement_ns": 324244, + "success": true + }, + { + "mutex_wait_ns": 675279, + "serialization_ns": 3667, + "serialized_bytes": 1300, + "statement_ns": 314767, + "success": true + }, + { + "mutex_wait_ns": 323403, + "serialization_ns": 3607, + "serialized_bytes": 1034, + "statement_ns": 325246, + "success": true + }, + { + "mutex_wait_ns": 242102, + "serialization_ns": 2024, + "serialized_bytes": 610, + "statement_ns": 413852, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2444, + "serialized_bytes": 610, + "statement_ns": 283289, + "success": true + }, + { + "mutex_wait_ns": 710345, + "serialization_ns": 3696, + "serialized_bytes": 1073, + "statement_ns": 316771, + "success": true + }, + { + "mutex_wait_ns": 326228, + "serialization_ns": 3066, + "serialized_bytes": 1034, + "statement_ns": 372775, + "success": true + }, + { + "mutex_wait_ns": 383014, + "serialization_ns": 4008, + "serialized_bytes": 1081, + "statement_ns": 336528, + "success": true + }, + { + "mutex_wait_ns": 343290, + "serialization_ns": 3276, + "serialized_bytes": 1073, + "statement_ns": 335325, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3316, + "serialized_bytes": 1081, + "statement_ns": 322842, + "success": true + }, + { + "mutex_wait_ns": 673446, + "serialization_ns": 3827, + "serialized_bytes": 1296, + "statement_ns": 350254, + "success": true + }, + { + "mutex_wait_ns": 357366, + "serialization_ns": 3657, + "serialized_bytes": 1296, + "statement_ns": 312102, + "success": true + }, + { + "mutex_wait_ns": 265936, + "serialization_ns": 2124, + "serialized_bytes": 610, + "statement_ns": 399755, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2555, + "serialized_bytes": 610, + "statement_ns": 337199, + "success": true + }, + { + "mutex_wait_ns": 682884, + "serialization_ns": 2244, + "serialized_bytes": 612, + "statement_ns": 368097, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2524, + "serialized_bytes": 612, + "statement_ns": 300711, + "success": true + }, + { + "mutex_wait_ns": 685478, + "serialization_ns": 2996, + "serialized_bytes": 1034, + "statement_ns": 333472, + "success": true + }, + { + "mutex_wait_ns": 342219, + "serialization_ns": 3396, + "serialized_bytes": 1038, + "statement_ns": 380339, + "success": true + }, + { + "mutex_wait_ns": 387092, + "serialization_ns": 3437, + "serialized_bytes": 1073, + "statement_ns": 336878, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3537, + "serialized_bytes": 1081, + "statement_ns": 358909, + "success": true + }, + { + "mutex_wait_ns": 711737, + "serialization_ns": 3647, + "serialized_bytes": 1077, + "statement_ns": 342359, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3717, + "serialized_bytes": 1085, + "statement_ns": 291704, + "success": true + }, + { + "mutex_wait_ns": 650393, + "serialization_ns": 3467, + "serialized_bytes": 1296, + "statement_ns": 381251, + "success": true + }, + { + "mutex_wait_ns": 388325, + "serialization_ns": 3677, + "serialized_bytes": 1300, + "statement_ns": 344833, + "success": true + }, + { + "mutex_wait_ns": 285743, + "serialization_ns": 2154, + "serialized_bytes": 612, + "statement_ns": 356194, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 2414, + "serialized_bytes": 612, + "statement_ns": 316540, + "success": true + }, + { + "mutex_wait_ns": 538514, + "serialization_ns": 2014, + "serialized_bytes": 610, + "statement_ns": 366063, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2374, + "serialized_bytes": 610, + "statement_ns": 275645, + "success": true + }, + { + "mutex_wait_ns": 657997, + "serialization_ns": 3276, + "serialized_bytes": 1038, + "statement_ns": 384538, + "success": true + }, + { + "mutex_wait_ns": 393504, + "serialization_ns": 3036, + "serialized_bytes": 1034, + "statement_ns": 361194, + "success": true + }, + { + "mutex_wait_ns": 367134, + "serialization_ns": 3477, + "serialized_bytes": 1077, + "statement_ns": 542763, + "success": true + }, + { + "mutex_wait_ns": 549655, + "serialization_ns": 3206, + "serialized_bytes": 1073, + "statement_ns": 422127, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3417, + "serialized_bytes": 1081, + "statement_ns": 304318, + "success": true + }, + { + "mutex_wait_ns": 745219, + "serialization_ns": 3617, + "serialized_bytes": 1085, + "statement_ns": 307334, + "success": true + }, + { + "mutex_wait_ns": 309397, + "serialization_ns": 3457, + "serialized_bytes": 1296, + "statement_ns": 343390, + "success": true + }, + { + "mutex_wait_ns": 350464, + "serialization_ns": 3987, + "serialized_bytes": 1300, + "statement_ns": 374168, + "success": true + }, + { + "mutex_wait_ns": 313395, + "serialization_ns": 1913, + "serialized_bytes": 612, + "statement_ns": 377554, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2234, + "serialized_bytes": 612, + "statement_ns": 281596, + "success": true + }, + { + "mutex_wait_ns": 618393, + "serialization_ns": 2124, + "serialized_bytes": 610, + "statement_ns": 356145, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2454, + "serialized_bytes": 610, + "statement_ns": 318574, + "success": true + }, + { + "mutex_wait_ns": 692491, + "serialization_ns": 3106, + "serialized_bytes": 1038, + "statement_ns": 306542, + "success": true + }, + { + "mutex_wait_ns": 316089, + "serialization_ns": 3356, + "serialized_bytes": 1034, + "statement_ns": 310499, + "success": true + }, + { + "mutex_wait_ns": 317452, + "serialization_ns": 3466, + "serialized_bytes": 1077, + "statement_ns": 303436, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3747, + "serialized_bytes": 1085, + "statement_ns": 308616, + "success": true + }, + { + "mutex_wait_ns": 625676, + "serialization_ns": 3617, + "serialized_bytes": 1073, + "statement_ns": 297726, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3877, + "serialized_bytes": 1081, + "statement_ns": 278038, + "success": true + }, + { + "mutex_wait_ns": 593126, + "serialization_ns": 3607, + "serialized_bytes": 1300, + "statement_ns": 395357, + "success": true + }, + { + "mutex_wait_ns": 402511, + "serialization_ns": 3817, + "serialized_bytes": 1296, + "statement_ns": 300711, + "success": true + }, + { + "mutex_wait_ns": 248193, + "serialization_ns": 1963, + "serialized_bytes": 612, + "statement_ns": 329365, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2404, + "serialized_bytes": 612, + "statement_ns": 310079, + "success": true + }, + { + "mutex_wait_ns": 601732, + "serialization_ns": 2094, + "serialized_bytes": 612, + "statement_ns": 342539, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2574, + "serialized_bytes": 612, + "statement_ns": 275654, + "success": true + }, + { + "mutex_wait_ns": 635064, + "serialization_ns": 2936, + "serialized_bytes": 1038, + "statement_ns": 348811, + "success": true + }, + { + "mutex_wait_ns": 357056, + "serialization_ns": 3547, + "serialized_bytes": 1038, + "statement_ns": 351295, + "success": true + }, + { + "mutex_wait_ns": 358829, + "serialization_ns": 3196, + "serialized_bytes": 1077, + "statement_ns": 284460, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3386, + "serialized_bytes": 1085, + "statement_ns": 365031, + "success": true + }, + { + "mutex_wait_ns": 665330, + "serialization_ns": 3497, + "serialized_bytes": 1077, + "statement_ns": 315539, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3677, + "serialized_bytes": 1085, + "statement_ns": 373727, + "success": true + }, + { + "mutex_wait_ns": 707810, + "serialization_ns": 3717, + "serialized_bytes": 1300, + "statement_ns": 348550, + "success": true + }, + { + "mutex_wait_ns": 352888, + "serialization_ns": 5540, + "serialized_bytes": 1300, + "statement_ns": 325127, + "success": true + }, + { + "mutex_wait_ns": 268351, + "serialization_ns": 4468, + "serialized_bytes": 612, + "statement_ns": 364319, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2395, + "serialized_bytes": 612, + "statement_ns": 289169, + "success": true + }, + { + "mutex_wait_ns": 601732, + "serialization_ns": 2875, + "serialized_bytes": 612, + "statement_ns": 340365, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2455, + "serialized_bytes": 612, + "statement_ns": 309878, + "success": true + }, + { + "mutex_wait_ns": 667225, + "serialization_ns": 3165, + "serialized_bytes": 1038, + "statement_ns": 291033, + "success": true + }, + { + "mutex_wait_ns": 300310, + "serialization_ns": 3056, + "serialized_bytes": 1038, + "statement_ns": 307323, + "success": true + }, + { + "mutex_wait_ns": 314316, + "serialization_ns": 3396, + "serialized_bytes": 1077, + "statement_ns": 369890, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3587, + "serialized_bytes": 1085, + "statement_ns": 292175, + "success": true + }, + { + "mutex_wait_ns": 677864, + "serialization_ns": 3246, + "serialized_bytes": 1077, + "statement_ns": 342519, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3547, + "serialized_bytes": 1085, + "statement_ns": 405757, + "success": true + }, + { + "mutex_wait_ns": 765147, + "serialization_ns": 3447, + "serialized_bytes": 1300, + "statement_ns": 372384, + "success": true + }, + { + "mutex_wait_ns": 379748, + "serialization_ns": 3737, + "serialized_bytes": 1300, + "statement_ns": 329636, + "success": true + }, + { + "mutex_wait_ns": 51, + "serialization_ns": 3546, + "serialized_bytes": 612, + "statement_ns": 392221, + "success": true + }, + { + "mutex_wait_ns": 150641, + "serialization_ns": 3587, + "serialized_bytes": 612, + "statement_ns": 329063, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3577, + "serialized_bytes": 612, + "statement_ns": 343761, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 5891, + "serialized_bytes": 1038, + "statement_ns": 363338, + "success": true + }, + { + "mutex_wait_ns": 1076547, + "serialization_ns": 6142, + "serialized_bytes": 612, + "statement_ns": 3456907, + "success": true + }, + { + "mutex_wait_ns": 51, + "serialization_ns": 6862, + "serialized_bytes": 1038, + "statement_ns": 446392, + "success": true + }, + { + "mutex_wait_ns": 60, + "serialization_ns": 7173, + "serialized_bytes": 1077, + "statement_ns": 306562, + "success": true + }, + { + "mutex_wait_ns": 4262630, + "serialization_ns": 5220, + "serialized_bytes": 1077, + "statement_ns": 332851, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 6021, + "serialized_bytes": 1085, + "statement_ns": 303186, + "success": true + }, + { + "mutex_wait_ns": 662315, + "serialization_ns": 5219, + "serialized_bytes": 1085, + "statement_ns": 302485, + "success": true + }, + { + "mutex_wait_ns": 309337, + "serialization_ns": 5710, + "serialized_bytes": 1300, + "statement_ns": 304758, + "success": true + }, + { + "mutex_wait_ns": 326258, + "serialization_ns": 5801, + "serialized_bytes": 1300, + "statement_ns": 401820, + "success": true + }, + { + "mutex_wait_ns": 312494, + "serialization_ns": 3386, + "serialized_bytes": 612, + "statement_ns": 382102, + "success": true + }, + { + "mutex_wait_ns": 203199, + "serialization_ns": 2034, + "serialized_bytes": 612, + "statement_ns": 424762, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3837, + "serialized_bytes": 612, + "statement_ns": 345514, + "success": true + }, + { + "mutex_wait_ns": 794833, + "serialization_ns": 4538, + "serialized_bytes": 612, + "statement_ns": 328142, + "success": true + }, + { + "mutex_wait_ns": 337159, + "serialization_ns": 4759, + "serialized_bytes": 1038, + "statement_ns": 361775, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 5390, + "serialized_bytes": 1077, + "statement_ns": 323073, + "success": true + }, + { + "mutex_wait_ns": 715114, + "serialization_ns": 5480, + "serialized_bytes": 1038, + "statement_ns": 379358, + "success": true + }, + { + "mutex_wait_ns": 391889, + "serialization_ns": 5290, + "serialized_bytes": 1085, + "statement_ns": 365692, + "success": true + }, + { + "mutex_wait_ns": 372746, + "serialization_ns": 5390, + "serialized_bytes": 1077, + "statement_ns": 350714, + "success": true + }, + { + "mutex_wait_ns": 361835, + "serialization_ns": 4138, + "serialized_bytes": 1300, + "statement_ns": 373436, + "success": true + }, + { + "mutex_wait_ns": 384477, + "serialization_ns": 5961, + "serialized_bytes": 1085, + "statement_ns": 384989, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 7274, + "serialized_bytes": 1300, + "statement_ns": 346055, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 929778, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=1", + "COMPILER=gcc-11.4.0", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_PTHREADS", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "HTTP", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 71517624, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 61516431, + 61931585, + 62083549, + 61693944, + 62031592, + 68466284, + 68818673, + 68490731, + 68828410, + 68535894, + 68867174, + 68540415, + 68862393, + 68851414, + 68554118, + 68850972, + 68565191, + 68871231, + 68730977, + 68832235, + 68827768, + 69158554, + 68848435, + 69187890, + 69152273, + 69189532, + 68877560, + 68819473, + 68891136, + 68826114, + 68895794, + 70661388 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 54146275, + 147967, + 118361, + 130503 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 54146275, + "end_ns": 64445170, + "in_window": true, + "scheduled_ns": null, + "start_ns": 10298895, + "success": true + }, + { + "elapsed_ns": 147967, + "end_ns": 74670371, + "in_window": false, + "scheduled_ns": null, + "start_ns": 74522404, + "success": true + }, + { + "elapsed_ns": 118361, + "end_ns": 84857751, + "in_window": false, + "scheduled_ns": null, + "start_ns": 84739390, + "success": true + }, + { + "elapsed_ns": 130503, + "end_ns": 95057694, + "in_window": false, + "scheduled_ns": null, + "start_ns": 94927191, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 4304579, + 48923097, + 766182, + 408225, + 609201, + 794988 + ], + "failures": 0, + "in_window_samples": 3, + "missed_periods": 4, + "samples": [ + { + "elapsed_ns": 4304579, + "end_ns": 16651260, + "in_window": true, + "scheduled_ns": 12346681, + "start_ns": 16651260, + "success": true + }, + { + "elapsed_ns": 48923097, + "end_ns": 71269778, + "in_window": true, + "scheduled_ns": 22346681, + "start_ns": 71269778, + "success": true + }, + { + "elapsed_ns": 766182, + "end_ns": 73112863, + "in_window": true, + "scheduled_ns": 72346681, + "start_ns": 73112863, + "success": true + }, + { + "elapsed_ns": 408225, + "end_ns": 82754906, + "in_window": false, + "scheduled_ns": 82346681, + "start_ns": 82754906, + "success": true + }, + { + "elapsed_ns": 609201, + "end_ns": 92955882, + "in_window": false, + "scheduled_ns": 92346681, + "start_ns": 92955882, + "success": true + }, + { + "elapsed_ns": 794988, + "end_ns": 103141669, + "in_window": false, + "scheduled_ns": 102346681, + "start_ns": 103141669, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 73876233, + "window_start_ns": 2358609 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 2, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 60, + "serialization_ns": 2445, + "serialized_bytes": 612, + "statement_ns": 388003, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2685, + "serialized_bytes": 612, + "statement_ns": 330657, + "success": true + }, + { + "mutex_wait_ns": 537773, + "serialization_ns": 2225, + "serialized_bytes": 610, + "statement_ns": 342338, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3056, + "serialized_bytes": 610, + "statement_ns": 300761, + "success": true + }, + { + "mutex_wait_ns": 659600, + "serialization_ns": 3737, + "serialized_bytes": 1038, + "statement_ns": 374819, + "success": true + }, + { + "mutex_wait_ns": 383625, + "serialization_ns": 3847, + "serialized_bytes": 1034, + "statement_ns": 526943, + "success": true + }, + { + "mutex_wait_ns": 531080, + "serialization_ns": 4158, + "serialized_bytes": 1077, + "statement_ns": 396510, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4279, + "serialized_bytes": 1085, + "statement_ns": 430963, + "success": true + }, + { + "mutex_wait_ns": 843984, + "serialization_ns": 3988, + "serialized_bytes": 1073, + "statement_ns": 437546, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3447, + "serialized_bytes": 1081, + "statement_ns": 411958, + "success": true + }, + { + "mutex_wait_ns": 866466, + "serialization_ns": 3897, + "serialized_bytes": 1300, + "statement_ns": 372194, + "success": true + }, + { + "mutex_wait_ns": 379748, + "serialization_ns": 3857, + "serialized_bytes": 1296, + "statement_ns": 364410, + "success": true + }, + { + "mutex_wait_ns": 320788, + "serialization_ns": 2505, + "serialized_bytes": 610, + "statement_ns": 342369, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2746, + "serialized_bytes": 610, + "statement_ns": 372124, + "success": true + }, + { + "mutex_wait_ns": 680639, + "serialization_ns": 2204, + "serialized_bytes": 612, + "statement_ns": 375821, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2615, + "serialized_bytes": 612, + "statement_ns": 296984, + "success": true + }, + { + "mutex_wait_ns": 688544, + "serialization_ns": 3466, + "serialized_bytes": 1034, + "statement_ns": 318685, + "success": true + }, + { + "mutex_wait_ns": 326829, + "serialization_ns": 3647, + "serialized_bytes": 1038, + "statement_ns": 378085, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3666, + "serialized_bytes": 1077, + "statement_ns": 338722, + "success": true + }, + { + "mutex_wait_ns": 736193, + "serialization_ns": 3346, + "serialized_bytes": 1073, + "statement_ns": 319666, + "success": true + }, + { + "mutex_wait_ns": 329204, + "serialization_ns": 3867, + "serialized_bytes": 1085, + "statement_ns": 357246, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3867, + "serialized_bytes": 1300, + "statement_ns": 282337, + "success": true + }, + { + "mutex_wait_ns": 661804, + "serialization_ns": 4027, + "serialized_bytes": 1081, + "statement_ns": 304699, + "success": true + }, + { + "mutex_wait_ns": 265725, + "serialization_ns": 2134, + "serialized_bytes": 612, + "statement_ns": 428590, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2354, + "serialized_bytes": 612, + "statement_ns": 293127, + "success": true + }, + { + "mutex_wait_ns": 736554, + "serialization_ns": 3957, + "serialized_bytes": 1296, + "statement_ns": 448576, + "success": true + }, + { + "mutex_wait_ns": 462192, + "serialization_ns": 3196, + "serialized_bytes": 1038, + "statement_ns": 342649, + "success": true + }, + { + "mutex_wait_ns": 308595, + "serialization_ns": 2084, + "serialized_bytes": 610, + "statement_ns": 442636, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2265, + "serialized_bytes": 610, + "statement_ns": 383515, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3386, + "serialized_bytes": 1034, + "statement_ns": 309788, + "success": true + }, + { + "mutex_wait_ns": 1161286, + "serialization_ns": 3556, + "serialized_bytes": 1077, + "statement_ns": 380239, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3847, + "serialized_bytes": 1085, + "statement_ns": 404694, + "success": true + }, + { + "mutex_wait_ns": 800673, + "serialization_ns": 3837, + "serialized_bytes": 1073, + "statement_ns": 351807, + "success": true + }, + { + "mutex_wait_ns": 358899, + "serialization_ns": 4008, + "serialized_bytes": 1300, + "statement_ns": 397932, + "success": true + }, + { + "mutex_wait_ns": 412940, + "serialization_ns": 3417, + "serialized_bytes": 1081, + "statement_ns": 376843, + "success": true + }, + { + "mutex_wait_ns": 324736, + "serialization_ns": 1873, + "serialized_bytes": 612, + "statement_ns": 318074, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2325, + "serialized_bytes": 612, + "statement_ns": 355693, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3296, + "serialized_bytes": 1038, + "statement_ns": 293477, + "success": true + }, + { + "mutex_wait_ns": 993503, + "serialization_ns": 3987, + "serialized_bytes": 1296, + "statement_ns": 307193, + "success": true + }, + { + "mutex_wait_ns": 313264, + "serialization_ns": 3767, + "serialized_bytes": 1077, + "statement_ns": 375550, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3857, + "serialized_bytes": 1085, + "statement_ns": 373737, + "success": true + }, + { + "mutex_wait_ns": 721887, + "serialization_ns": 2073, + "serialized_bytes": 610, + "statement_ns": 382012, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2445, + "serialized_bytes": 610, + "statement_ns": 311711, + "success": true + }, + { + "mutex_wait_ns": 709263, + "serialization_ns": 3817, + "serialized_bytes": 1300, + "statement_ns": 320338, + "success": true + }, + { + "mutex_wait_ns": 330306, + "serialization_ns": 3026, + "serialized_bytes": 1034, + "statement_ns": 332450, + "success": true + }, + { + "mutex_wait_ns": 298106, + "serialization_ns": 1974, + "serialized_bytes": 610, + "statement_ns": 305419, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2485, + "serialized_bytes": 610, + "statement_ns": 311801, + "success": true + }, + { + "mutex_wait_ns": 635014, + "serialization_ns": 3276, + "serialized_bytes": 1073, + "statement_ns": 514971, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3487, + "serialized_bytes": 1081, + "statement_ns": 338701, + "success": true + }, + { + "mutex_wait_ns": 873199, + "serialization_ns": 3056, + "serialized_bytes": 1034, + "statement_ns": 342138, + "success": true + }, + { + "mutex_wait_ns": 350113, + "serialization_ns": 3606, + "serialized_bytes": 1296, + "statement_ns": 448908, + "success": true + }, + { + "mutex_wait_ns": 460118, + "serialization_ns": 3527, + "serialized_bytes": 1073, + "statement_ns": 381762, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3787, + "serialized_bytes": 1081, + "statement_ns": 303697, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3697, + "serialized_bytes": 1296, + "statement_ns": 315428, + "success": true + }, + { + "mutex_wait_ns": 986841, + "serialization_ns": 2494, + "serialized_bytes": 612, + "statement_ns": 330837, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2294, + "serialized_bytes": 612, + "statement_ns": 332099, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3276, + "serialized_bytes": 1038, + "statement_ns": 341416, + "success": true + }, + { + "mutex_wait_ns": 983264, + "serialization_ns": 2465, + "serialized_bytes": 610, + "statement_ns": 343200, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2545, + "serialized_bytes": 610, + "statement_ns": 317713, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3446, + "serialized_bytes": 1034, + "statement_ns": 282587, + "success": true + }, + { + "mutex_wait_ns": 967925, + "serialization_ns": 3627, + "serialized_bytes": 1077, + "statement_ns": 295431, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3817, + "serialized_bytes": 1085, + "statement_ns": 315328, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3758, + "serialized_bytes": 1300, + "statement_ns": 356265, + "success": true + }, + { + "mutex_wait_ns": 996077, + "serialization_ns": 3136, + "serialized_bytes": 1073, + "statement_ns": 385169, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3627, + "serialized_bytes": 1081, + "statement_ns": 345975, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3507, + "serialized_bytes": 1296, + "statement_ns": 342027, + "success": true + }, + { + "mutex_wait_ns": 1057813, + "serialization_ns": 1974, + "serialized_bytes": 610, + "statement_ns": 334303, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2485, + "serialized_bytes": 610, + "statement_ns": 294218, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3075, + "serialized_bytes": 1034, + "statement_ns": 296093, + "success": true + }, + { + "mutex_wait_ns": 904527, + "serialization_ns": 1953, + "serialized_bytes": 612, + "statement_ns": 318594, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2405, + "serialized_bytes": 612, + "statement_ns": 272478, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3427, + "serialized_bytes": 1038, + "statement_ns": 286264, + "success": true + }, + { + "mutex_wait_ns": 901491, + "serialization_ns": 3277, + "serialized_bytes": 1073, + "statement_ns": 305850, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3637, + "serialized_bytes": 1081, + "statement_ns": 347157, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3817, + "serialized_bytes": 1296, + "statement_ns": 289520, + "success": true + }, + { + "mutex_wait_ns": 970200, + "serialization_ns": 3797, + "serialized_bytes": 1077, + "statement_ns": 280072, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3707, + "serialized_bytes": 1085, + "statement_ns": 391320, + "success": true + }, + { + "mutex_wait_ns": 653629, + "serialization_ns": 2515, + "serialized_bytes": 612, + "statement_ns": 366163, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2484, + "serialized_bytes": 612, + "statement_ns": 289530, + "success": true + }, + { + "mutex_wait_ns": 671984, + "serialization_ns": 8215, + "serialized_bytes": 1300, + "statement_ns": 340555, + "success": true + }, + { + "mutex_wait_ns": 352567, + "serialization_ns": 3166, + "serialized_bytes": 1038, + "statement_ns": 351345, + "success": true + }, + { + "mutex_wait_ns": 317051, + "serialization_ns": 1994, + "serialized_bytes": 610, + "statement_ns": 313785, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2375, + "serialized_bytes": 610, + "statement_ns": 283849, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3036, + "serialized_bytes": 1034, + "statement_ns": 289931, + "success": true + }, + { + "mutex_wait_ns": 912492, + "serialization_ns": 3496, + "serialized_bytes": 1077, + "statement_ns": 295641, + "success": true + }, + { + "mutex_wait_ns": 302114, + "serialization_ns": 3276, + "serialized_bytes": 1073, + "statement_ns": 329705, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3566, + "serialized_bytes": 1081, + "statement_ns": 284240, + "success": true + }, + { + "mutex_wait_ns": 633532, + "serialization_ns": 3627, + "serialized_bytes": 1085, + "statement_ns": 292886, + "success": true + }, + { + "mutex_wait_ns": 300271, + "serialization_ns": 3616, + "serialized_bytes": 1296, + "statement_ns": 274401, + "success": true + }, + { + "mutex_wait_ns": 282167, + "serialization_ns": 3827, + "serialized_bytes": 1300, + "statement_ns": 406979, + "success": true + }, + { + "mutex_wait_ns": 365852, + "serialization_ns": 6392, + "serialized_bytes": 612, + "statement_ns": 301442, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2564, + "serialized_bytes": 612, + "statement_ns": 258462, + "success": true + }, + { + "mutex_wait_ns": 528836, + "serialization_ns": 2064, + "serialized_bytes": 612, + "statement_ns": 353329, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2515, + "serialized_bytes": 612, + "statement_ns": 356495, + "success": true + }, + { + "mutex_wait_ns": 725634, + "serialization_ns": 3246, + "serialized_bytes": 1038, + "statement_ns": 385289, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3547, + "serialized_bytes": 1077, + "statement_ns": 362506, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3607, + "serialized_bytes": 1085, + "statement_ns": 283710, + "success": true + }, + { + "mutex_wait_ns": 1064055, + "serialization_ns": 3005, + "serialized_bytes": 1038, + "statement_ns": 315007, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3316, + "serialized_bytes": 1077, + "statement_ns": 345164, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3587, + "serialized_bytes": 1085, + "statement_ns": 299558, + "success": true + }, + { + "mutex_wait_ns": 988583, + "serialization_ns": 3417, + "serialized_bytes": 1300, + "statement_ns": 286966, + "success": true + }, + { + "mutex_wait_ns": 293798, + "serialization_ns": 3637, + "serialized_bytes": 1300, + "statement_ns": 392352, + "success": true + }, + { + "mutex_wait_ns": 325908, + "serialization_ns": 1964, + "serialized_bytes": 612, + "statement_ns": 316821, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2334, + "serialized_bytes": 612, + "statement_ns": 261888, + "success": true + }, + { + "mutex_wait_ns": 540217, + "serialization_ns": 1964, + "serialized_bytes": 612, + "statement_ns": 393634, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2375, + "serialized_bytes": 612, + "statement_ns": 319255, + "success": true + }, + { + "mutex_wait_ns": 705906, + "serialization_ns": 26289, + "serialized_bytes": 1038, + "statement_ns": 343842, + "success": true + }, + { + "mutex_wait_ns": 356124, + "serialization_ns": 3025, + "serialized_bytes": 1038, + "statement_ns": 327010, + "success": true + }, + { + "mutex_wait_ns": 337569, + "serialization_ns": 3307, + "serialized_bytes": 1077, + "statement_ns": 280984, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3437, + "serialized_bytes": 1085, + "statement_ns": 261007, + "success": true + }, + { + "mutex_wait_ns": 557690, + "serialization_ns": 3516, + "serialized_bytes": 1077, + "statement_ns": 337630, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3737, + "serialized_bytes": 1085, + "statement_ns": 304268, + "success": true + }, + { + "mutex_wait_ns": 658889, + "serialization_ns": 3426, + "serialized_bytes": 1300, + "statement_ns": 278750, + "success": true + }, + { + "mutex_wait_ns": 286274, + "serialization_ns": 3506, + "serialized_bytes": 1300, + "statement_ns": 360573, + "success": true + }, + { + "mutex_wait_ns": 227193, + "serialization_ns": 2275, + "serialized_bytes": 612, + "statement_ns": 315459, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2295, + "serialized_bytes": 612, + "statement_ns": 305920, + "success": true + }, + { + "mutex_wait_ns": 590701, + "serialization_ns": 2114, + "serialized_bytes": 610, + "statement_ns": 403683, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2465, + "serialized_bytes": 610, + "statement_ns": 315619, + "success": true + }, + { + "mutex_wait_ns": 736454, + "serialization_ns": 3175, + "serialized_bytes": 1038, + "statement_ns": 285843, + "success": true + }, + { + "mutex_wait_ns": 295210, + "serialization_ns": 3166, + "serialized_bytes": 1034, + "statement_ns": 336628, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3426, + "serialized_bytes": 1073, + "statement_ns": 301743, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3436, + "serialized_bytes": 1081, + "statement_ns": 345093, + "success": true + }, + { + "mutex_wait_ns": 1012018, + "serialization_ns": 3547, + "serialized_bytes": 1077, + "statement_ns": 341286, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3747, + "serialized_bytes": 1085, + "statement_ns": 317382, + "success": true + }, + { + "mutex_wait_ns": 675971, + "serialization_ns": 3676, + "serialized_bytes": 1296, + "statement_ns": 307363, + "success": true + }, + { + "mutex_wait_ns": 315128, + "serialization_ns": 3697, + "serialized_bytes": 1300, + "statement_ns": 379718, + "success": true + }, + { + "mutex_wait_ns": 311962, + "serialization_ns": 2064, + "serialized_bytes": 612, + "statement_ns": 361484, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 2225, + "serialized_bytes": 612, + "statement_ns": 320799, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3136, + "serialized_bytes": 1038, + "statement_ns": 294880, + "success": true + }, + { + "mutex_wait_ns": 956373, + "serialization_ns": 2144, + "serialized_bytes": 612, + "statement_ns": 326850, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2505, + "serialized_bytes": 612, + "statement_ns": 277427, + "success": true + }, + { + "mutex_wait_ns": 633080, + "serialization_ns": 3317, + "serialized_bytes": 1077, + "statement_ns": 314156, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3787, + "serialized_bytes": 1085, + "statement_ns": 290562, + "success": true + }, + { + "mutex_wait_ns": 621799, + "serialization_ns": 4248, + "serialized_bytes": 1038, + "statement_ns": 299639, + "success": true + }, + { + "mutex_wait_ns": 306963, + "serialization_ns": 3536, + "serialized_bytes": 1300, + "statement_ns": 362726, + "success": true + }, + { + "mutex_wait_ns": 374278, + "serialization_ns": 3596, + "serialized_bytes": 1077, + "statement_ns": 308375, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3817, + "serialized_bytes": 1085, + "statement_ns": 302204, + "success": true + }, + { + "mutex_wait_ns": 574953, + "serialization_ns": 2144, + "serialized_bytes": 610, + "statement_ns": 374618, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2625, + "serialized_bytes": 610, + "statement_ns": 278089, + "success": true + }, + { + "mutex_wait_ns": 668086, + "serialization_ns": 3647, + "serialized_bytes": 1300, + "statement_ns": 3143633, + "success": true + }, + { + "mutex_wait_ns": 3161036, + "serialization_ns": 3135, + "serialized_bytes": 1034, + "statement_ns": 476419, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4098, + "serialized_bytes": 1073, + "statement_ns": 390648, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3497, + "serialized_bytes": 1081, + "statement_ns": 389266, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3587, + "serialized_bytes": 1296, + "statement_ns": 332059, + "success": true + }, + { + "mutex_wait_ns": 1583793, + "serialization_ns": 2665, + "serialized_bytes": 612, + "statement_ns": 367957, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2565, + "serialized_bytes": 612, + "statement_ns": 338802, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3417, + "serialized_bytes": 1038, + "statement_ns": 305750, + "success": true + }, + { + "mutex_wait_ns": 987251, + "serialization_ns": 1994, + "serialized_bytes": 612, + "statement_ns": 367376, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2695, + "serialized_bytes": 612, + "statement_ns": 348540, + "success": true + }, + { + "mutex_wait_ns": 730402, + "serialization_ns": 3957, + "serialized_bytes": 1077, + "statement_ns": 365632, + "success": true + }, + { + "mutex_wait_ns": 375530, + "serialization_ns": 3256, + "serialized_bytes": 1038, + "statement_ns": 334164, + "success": true + }, + { + "mutex_wait_ns": 344132, + "serialization_ns": 3797, + "serialized_bytes": 1085, + "statement_ns": 396369, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3717, + "serialized_bytes": 1300, + "statement_ns": 365582, + "success": true + }, + { + "mutex_wait_ns": 781749, + "serialization_ns": 3476, + "serialized_bytes": 1077, + "statement_ns": 346676, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3506, + "serialized_bytes": 1085, + "statement_ns": 317752, + "success": true + }, + { + "mutex_wait_ns": 629514, + "serialization_ns": 2134, + "serialized_bytes": 612, + "statement_ns": 328833, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2424, + "serialized_bytes": 612, + "statement_ns": 326298, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3066, + "serialized_bytes": 1038, + "statement_ns": 339914, + "success": true + }, + { + "mutex_wait_ns": 1022196, + "serialization_ns": 3497, + "serialized_bytes": 1300, + "statement_ns": 334324, + "success": true + }, + { + "mutex_wait_ns": 341788, + "serialization_ns": 3366, + "serialized_bytes": 1077, + "statement_ns": 304748, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3557, + "serialized_bytes": 1085, + "statement_ns": 319997, + "success": true + }, + { + "mutex_wait_ns": 596232, + "serialization_ns": 2425, + "serialized_bytes": 612, + "statement_ns": 379738, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2494, + "serialized_bytes": 612, + "statement_ns": 378106, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3095, + "serialized_bytes": 1038, + "statement_ns": 320908, + "success": true + }, + { + "mutex_wait_ns": 1105082, + "serialization_ns": 3566, + "serialized_bytes": 1300, + "statement_ns": 318023, + "success": true + }, + { + "mutex_wait_ns": 325216, + "serialization_ns": 3186, + "serialized_bytes": 1077, + "statement_ns": 346714, + "success": true + }, + { + "mutex_wait_ns": 12373, + "serialization_ns": 2114, + "serialized_bytes": 612, + "statement_ns": 319185, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2465, + "serialized_bytes": 612, + "statement_ns": 280413, + "success": true + }, + { + "mutex_wait_ns": 614436, + "serialization_ns": 5450, + "serialized_bytes": 1085, + "statement_ns": 374575, + "success": true + }, + { + "mutex_wait_ns": 385008, + "serialization_ns": 3547, + "serialized_bytes": 1038, + "statement_ns": 303546, + "success": true + }, + { + "mutex_wait_ns": 308866, + "serialization_ns": 6562, + "serialized_bytes": 1300, + "statement_ns": 286425, + "success": true + }, + { + "mutex_wait_ns": 292606, + "serialization_ns": 5190, + "serialized_bytes": 1077, + "statement_ns": 362596, + "success": true + }, + { + "mutex_wait_ns": 298577, + "serialization_ns": 2975, + "serialized_bytes": 612, + "statement_ns": 354060, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3757, + "serialized_bytes": 612, + "statement_ns": 287877, + "success": true + }, + { + "mutex_wait_ns": 665441, + "serialization_ns": 5841, + "serialized_bytes": 1085, + "statement_ns": 341026, + "success": true + }, + { + "mutex_wait_ns": 351545, + "serialization_ns": 4940, + "serialized_bytes": 1038, + "statement_ns": 291834, + "success": true + }, + { + "mutex_wait_ns": 297435, + "serialization_ns": 6622, + "serialized_bytes": 1300, + "statement_ns": 324365, + "success": true + }, + { + "mutex_wait_ns": 330517, + "serialization_ns": 5310, + "serialized_bytes": 1077, + "statement_ns": 521602, + "success": true + }, + { + "mutex_wait_ns": 450711, + "serialization_ns": 3206, + "serialized_bytes": 612, + "statement_ns": 399515, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3446, + "serialized_bytes": 612, + "statement_ns": 405507, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5420, + "serialized_bytes": 1038, + "statement_ns": 320998, + "success": true + }, + { + "mutex_wait_ns": 1165694, + "serialization_ns": 5531, + "serialized_bytes": 1085, + "statement_ns": 319305, + "success": true + }, + { + "mutex_wait_ns": 325416, + "serialization_ns": 5210, + "serialized_bytes": 1077, + "statement_ns": 298437, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 5791, + "serialized_bytes": 1085, + "statement_ns": 287215, + "success": true + }, + { + "mutex_wait_ns": 607914, + "serialization_ns": 6051, + "serialized_bytes": 1300, + "statement_ns": 289790, + "success": true + }, + { + "mutex_wait_ns": 297174, + "serialization_ns": 5831, + "serialized_bytes": 1300, + "statement_ns": 496226, + "success": true + }, + { + "mutex_wait_ns": 139651, + "serialization_ns": 2053, + "serialized_bytes": 612, + "statement_ns": 416617, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5029, + "serialized_bytes": 612, + "statement_ns": 314206, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3377, + "serialized_bytes": 1038, + "statement_ns": 302133, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3316, + "serialized_bytes": 1077, + "statement_ns": 300731, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3597, + "serialized_bytes": 1085, + "statement_ns": 374959, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3687, + "serialized_bytes": 1300, + "statement_ns": 321780, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 1090284, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=1", + "COMPILER=gcc-11.4.0", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_PTHREADS", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "HTTP", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 153055054, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 97513706, + 104809306, + 104822939, + 104860601, + 105628452, + 104877822, + 105471899, + 113239869, + 113342609, + 113302223, + 113035797, + 113293277, + 113563293, + 113932611, + 117021112, + 117893146, + 120000809, + 121681090, + 125262679, + 125876605, + 128149413, + 129942475, + 132739878, + 134099509, + 137009547, + 138731858, + 141605999, + 143522807, + 144864297, + 147661463, + 148923208, + 152078543 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 35581691, + 27673486, + 14223167, + 133760, + 226022, + 117720, + 112570, + 133379, + 129862 + ], + "failures": 0, + "in_window_samples": 7, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 35581691, + "end_ns": 45877747, + "in_window": true, + "scheduled_ns": null, + "start_ns": 10296056, + "success": true + }, + { + "elapsed_ns": 27673486, + "end_ns": 83623699, + "in_window": true, + "scheduled_ns": null, + "start_ns": 55950213, + "success": true + }, + { + "elapsed_ns": 14223167, + "end_ns": 107918516, + "in_window": true, + "scheduled_ns": null, + "start_ns": 93695349, + "success": true + }, + { + "elapsed_ns": 133760, + "end_ns": 118126735, + "in_window": true, + "scheduled_ns": null, + "start_ns": 117992975, + "success": true + }, + { + "elapsed_ns": 226022, + "end_ns": 128427947, + "in_window": true, + "scheduled_ns": null, + "start_ns": 128201925, + "success": true + }, + { + "elapsed_ns": 117720, + "end_ns": 138614996, + "in_window": true, + "scheduled_ns": null, + "start_ns": 138497276, + "success": true + }, + { + "elapsed_ns": 112570, + "end_ns": 148793369, + "in_window": true, + "scheduled_ns": null, + "start_ns": 148680799, + "success": true + }, + { + "elapsed_ns": 133379, + "end_ns": 158996919, + "in_window": false, + "scheduled_ns": null, + "start_ns": 158863540, + "success": true + }, + { + "elapsed_ns": 129862, + "end_ns": 169198055, + "in_window": false, + "scheduled_ns": null, + "start_ns": 169068193, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 32625291, + 15827371, + 31390861, + 3804383, + 1036040, + 1058720, + 1134633, + 1136908, + 710302, + 911217, + 1009040 + ], + "failures": 0, + "in_window_samples": 8, + "missed_periods": 7, + "samples": [ + { + "elapsed_ns": 32625291, + "end_ns": 44973247, + "in_window": true, + "scheduled_ns": 12347956, + "start_ns": 44973247, + "success": true + }, + { + "elapsed_ns": 15827371, + "end_ns": 68175327, + "in_window": true, + "scheduled_ns": 52347956, + "start_ns": 68175327, + "success": true + }, + { + "elapsed_ns": 31390861, + "end_ns": 103738817, + "in_window": true, + "scheduled_ns": 72347956, + "start_ns": 103738817, + "success": true + }, + { + "elapsed_ns": 3804383, + "end_ns": 116152339, + "in_window": true, + "scheduled_ns": 112347956, + "start_ns": 116152339, + "success": true + }, + { + "elapsed_ns": 1036040, + "end_ns": 123383996, + "in_window": true, + "scheduled_ns": 122347956, + "start_ns": 123383996, + "success": true + }, + { + "elapsed_ns": 1058720, + "end_ns": 133406676, + "in_window": true, + "scheduled_ns": 132347956, + "start_ns": 133406676, + "success": true + }, + { + "elapsed_ns": 1134633, + "end_ns": 143482589, + "in_window": true, + "scheduled_ns": 142347956, + "start_ns": 143482589, + "success": true + }, + { + "elapsed_ns": 1136908, + "end_ns": 153484864, + "in_window": true, + "scheduled_ns": 152347956, + "start_ns": 153484864, + "success": true + }, + { + "elapsed_ns": 710302, + "end_ns": 163058258, + "in_window": false, + "scheduled_ns": 162347956, + "start_ns": 163058258, + "success": true + }, + { + "elapsed_ns": 911217, + "end_ns": 173259173, + "in_window": false, + "scheduled_ns": 172347956, + "start_ns": 173259173, + "success": true + }, + { + "elapsed_ns": 1009040, + "end_ns": 183356996, + "in_window": false, + "scheduled_ns": 182347956, + "start_ns": 183356996, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 155416371, + "window_start_ns": 2361317 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 0, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 50, + "serialization_ns": 5430, + "serialized_bytes": 613, + "statement_ns": 658488, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3447, + "serialized_bytes": 613, + "statement_ns": 369629, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5801, + "serialized_bytes": 1040, + "statement_ns": 345695, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5290, + "serialized_bytes": 1079, + "statement_ns": 369880, + "success": true + }, + { + "mutex_wait_ns": 42399, + "serialization_ns": 2054, + "serialized_bytes": 613, + "statement_ns": 332299, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2986, + "serialized_bytes": 613, + "statement_ns": 286444, + "success": true + }, + { + "mutex_wait_ns": 640915, + "serialization_ns": 5060, + "serialized_bytes": 1087, + "statement_ns": 341537, + "success": true + }, + { + "mutex_wait_ns": 349892, + "serialization_ns": 4699, + "serialized_bytes": 1040, + "statement_ns": 297255, + "success": true + }, + { + "mutex_wait_ns": 302315, + "serialization_ns": 6371, + "serialized_bytes": 1302, + "statement_ns": 299518, + "success": true + }, + { + "mutex_wait_ns": 305659, + "serialization_ns": 5000, + "serialized_bytes": 1079, + "statement_ns": 412189, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 5109, + "serialized_bytes": 1087, + "statement_ns": 320879, + "success": true + }, + { + "mutex_wait_ns": 49, + "serialization_ns": 5922, + "serialized_bytes": 1302, + "statement_ns": 325007, + "success": true + }, + { + "mutex_wait_ns": 291684, + "serialization_ns": 3146, + "serialized_bytes": 613, + "statement_ns": 383706, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3176, + "serialized_bytes": 613, + "statement_ns": 330767, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 7734, + "serialized_bytes": 1040, + "statement_ns": 371513, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 5019, + "serialized_bytes": 1079, + "statement_ns": 318124, + "success": true + }, + { + "mutex_wait_ns": 224288, + "serialization_ns": 3196, + "serialized_bytes": 613, + "statement_ns": 350103, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3267, + "serialized_bytes": 613, + "statement_ns": 299209, + "success": true + }, + { + "mutex_wait_ns": 672103, + "serialization_ns": 5210, + "serialized_bytes": 1087, + "statement_ns": 290753, + "success": true + }, + { + "mutex_wait_ns": 300000, + "serialization_ns": 4889, + "serialized_bytes": 1040, + "statement_ns": 413300, + "success": true + }, + { + "mutex_wait_ns": 419382, + "serialization_ns": 6111, + "serialized_bytes": 1302, + "statement_ns": 397050, + "success": true + }, + { + "mutex_wait_ns": 402831, + "serialization_ns": 5540, + "serialized_bytes": 1079, + "statement_ns": 329325, + "success": true + }, + { + "mutex_wait_ns": 206746, + "serialization_ns": 3015, + "serialized_bytes": 613, + "statement_ns": 325086, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 3857, + "serialized_bytes": 613, + "statement_ns": 307153, + "success": true + }, + { + "mutex_wait_ns": 676341, + "serialization_ns": 5250, + "serialized_bytes": 1087, + "statement_ns": 295512, + "success": true + }, + { + "mutex_wait_ns": 304709, + "serialization_ns": 4819, + "serialized_bytes": 1040, + "statement_ns": 309046, + "success": true + }, + { + "mutex_wait_ns": 315328, + "serialization_ns": 5921, + "serialized_bytes": 1302, + "statement_ns": 370030, + "success": true + }, + { + "mutex_wait_ns": 376212, + "serialization_ns": 5200, + "serialized_bytes": 1079, + "statement_ns": 327210, + "success": true + }, + { + "mutex_wait_ns": 203460, + "serialization_ns": 2013, + "serialized_bytes": 613, + "statement_ns": 393193, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3897, + "serialized_bytes": 613, + "statement_ns": 288087, + "success": true + }, + { + "mutex_wait_ns": 704594, + "serialization_ns": 5490, + "serialized_bytes": 1087, + "statement_ns": 282006, + "success": true + }, + { + "mutex_wait_ns": 290572, + "serialization_ns": 5210, + "serialized_bytes": 1040, + "statement_ns": 277908, + "success": true + }, + { + "mutex_wait_ns": 284952, + "serialization_ns": 6151, + "serialized_bytes": 1302, + "statement_ns": 385549, + "success": true + }, + { + "mutex_wait_ns": 391931, + "serialization_ns": 5790, + "serialized_bytes": 1079, + "statement_ns": 315639, + "success": true + }, + { + "mutex_wait_ns": 200995, + "serialization_ns": 3637, + "serialized_bytes": 613, + "statement_ns": 353499, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3716, + "serialized_bytes": 613, + "statement_ns": 283339, + "success": true + }, + { + "mutex_wait_ns": 660391, + "serialization_ns": 5210, + "serialized_bytes": 1087, + "statement_ns": 288949, + "success": true + }, + { + "mutex_wait_ns": 298677, + "serialization_ns": 4729, + "serialized_bytes": 1040, + "statement_ns": 357106, + "success": true + }, + { + "mutex_wait_ns": 364560, + "serialization_ns": 6041, + "serialized_bytes": 1302, + "statement_ns": 330757, + "success": true + }, + { + "mutex_wait_ns": 338121, + "serialization_ns": 5601, + "serialized_bytes": 1079, + "statement_ns": 349932, + "success": true + }, + { + "mutex_wait_ns": 203610, + "serialization_ns": 1963, + "serialized_bytes": 611, + "statement_ns": 375090, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3486, + "serialized_bytes": 611, + "statement_ns": 296233, + "success": true + }, + { + "mutex_wait_ns": 694606, + "serialization_ns": 5259, + "serialized_bytes": 1087, + "statement_ns": 296342, + "success": true + }, + { + "mutex_wait_ns": 305580, + "serialization_ns": 4628, + "serialized_bytes": 1036, + "statement_ns": 315719, + "success": true + }, + { + "mutex_wait_ns": 51, + "serialization_ns": 5139, + "serialized_bytes": 1075, + "statement_ns": 299398, + "success": true + }, + { + "mutex_wait_ns": 641847, + "serialization_ns": 6001, + "serialized_bytes": 1302, + "statement_ns": 316270, + "success": true + }, + { + "mutex_wait_ns": 328493, + "serialization_ns": 5179, + "serialized_bytes": 1083, + "statement_ns": 338602, + "success": true + }, + { + "mutex_wait_ns": 220221, + "serialization_ns": 3156, + "serialized_bytes": 613, + "statement_ns": 323363, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3737, + "serialized_bytes": 613, + "statement_ns": 276045, + "success": true + }, + { + "mutex_wait_ns": 617281, + "serialization_ns": 6152, + "serialized_bytes": 1298, + "statement_ns": 349762, + "success": true + }, + { + "mutex_wait_ns": 369429, + "serialization_ns": 4619, + "serialized_bytes": 1040, + "statement_ns": 319626, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5350, + "serialized_bytes": 1079, + "statement_ns": 339713, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5400, + "serialized_bytes": 1087, + "statement_ns": 335175, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 5611, + "serialized_bytes": 1302, + "statement_ns": 372295, + "success": true + }, + { + "mutex_wait_ns": 162152, + "serialization_ns": 1994, + "serialized_bytes": 613, + "statement_ns": 391010, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3076, + "serialized_bytes": 613, + "statement_ns": 329023, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5199, + "serialized_bytes": 1040, + "statement_ns": 318865, + "success": true + }, + { + "mutex_wait_ns": 223868, + "serialization_ns": 2765, + "serialized_bytes": 613, + "statement_ns": 323714, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3306, + "serialized_bytes": 613, + "statement_ns": 299829, + "success": true + }, + { + "mutex_wait_ns": 641667, + "serialization_ns": 5060, + "serialized_bytes": 1079, + "statement_ns": 292565, + "success": true + }, + { + "mutex_wait_ns": 301733, + "serialization_ns": 4979, + "serialized_bytes": 1040, + "statement_ns": 282156, + "success": true + }, + { + "mutex_wait_ns": 292967, + "serialization_ns": 5280, + "serialized_bytes": 1087, + "statement_ns": 322121, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 6202, + "serialized_bytes": 1302, + "statement_ns": 288939, + "success": true + }, + { + "mutex_wait_ns": 637730, + "serialization_ns": 5179, + "serialized_bytes": 1079, + "statement_ns": 303496, + "success": true + }, + { + "mutex_wait_ns": 184444, + "serialization_ns": 2043, + "serialized_bytes": 613, + "statement_ns": 352558, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2956, + "serialized_bytes": 613, + "statement_ns": 282276, + "success": true + }, + { + "mutex_wait_ns": 657136, + "serialization_ns": 5049, + "serialized_bytes": 1087, + "statement_ns": 344492, + "success": true + }, + { + "mutex_wait_ns": 353719, + "serialization_ns": 4479, + "serialized_bytes": 1040, + "statement_ns": 517836, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5500, + "serialized_bytes": 1079, + "statement_ns": 357046, + "success": true + }, + { + "mutex_wait_ns": 902253, + "serialization_ns": 5781, + "serialized_bytes": 1302, + "statement_ns": 361895, + "success": true + }, + { + "mutex_wait_ns": 383245, + "serialization_ns": 5350, + "serialized_bytes": 1087, + "statement_ns": 337169, + "success": true + }, + { + "mutex_wait_ns": 227815, + "serialization_ns": 3406, + "serialized_bytes": 611, + "statement_ns": 345174, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 3427, + "serialized_bytes": 611, + "statement_ns": 342508, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 5080, + "serialized_bytes": 1036, + "statement_ns": 302935, + "success": true + }, + { + "mutex_wait_ns": 1026214, + "serialization_ns": 5459, + "serialized_bytes": 1302, + "statement_ns": 311201, + "success": true + }, + { + "mutex_wait_ns": 318644, + "serialization_ns": 4889, + "serialized_bytes": 1075, + "statement_ns": 355764, + "success": true + }, + { + "mutex_wait_ns": 60, + "serialization_ns": 5090, + "serialized_bytes": 1083, + "statement_ns": 303806, + "success": true + }, + { + "mutex_wait_ns": 530309, + "serialization_ns": 1903, + "serialized_bytes": 611, + "statement_ns": 371042, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3437, + "serialized_bytes": 611, + "statement_ns": 305790, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5030, + "serialized_bytes": 1036, + "statement_ns": 295952, + "success": true + }, + { + "mutex_wait_ns": 1008060, + "serialization_ns": 5561, + "serialized_bytes": 1298, + "statement_ns": 386020, + "success": true + }, + { + "mutex_wait_ns": 393364, + "serialization_ns": 4669, + "serialized_bytes": 1075, + "statement_ns": 370941, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 5480, + "serialized_bytes": 1083, + "statement_ns": 335706, + "success": true + }, + { + "mutex_wait_ns": 229669, + "serialization_ns": 3396, + "serialized_bytes": 611, + "statement_ns": 369709, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3457, + "serialized_bytes": 611, + "statement_ns": 306641, + "success": true + }, + { + "mutex_wait_ns": 712589, + "serialization_ns": 5360, + "serialized_bytes": 1298, + "statement_ns": 303376, + "success": true + }, + { + "mutex_wait_ns": 312944, + "serialization_ns": 4829, + "serialized_bytes": 1036, + "statement_ns": 331067, + "success": true + }, + { + "mutex_wait_ns": 223106, + "serialization_ns": 2174, + "serialized_bytes": 613, + "statement_ns": 380499, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3286, + "serialized_bytes": 613, + "statement_ns": 289184, + "success": true + }, + { + "mutex_wait_ns": 683214, + "serialization_ns": 5259, + "serialized_bytes": 1075, + "statement_ns": 348310, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3837, + "serialized_bytes": 1083, + "statement_ns": 290322, + "success": true + }, + { + "mutex_wait_ns": 656043, + "serialization_ns": 3918, + "serialized_bytes": 1040, + "statement_ns": 360292, + "success": true + }, + { + "mutex_wait_ns": 366684, + "serialization_ns": 3567, + "serialized_bytes": 1298, + "statement_ns": 355623, + "success": true + }, + { + "mutex_wait_ns": 359470, + "serialization_ns": 3867, + "serialized_bytes": 1079, + "statement_ns": 334073, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3947, + "serialized_bytes": 1087, + "statement_ns": 325767, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4708, + "serialized_bytes": 1302, + "statement_ns": 356195, + "success": true + }, + { + "mutex_wait_ns": 313755, + "serialization_ns": 2064, + "serialized_bytes": 611, + "statement_ns": 423540, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 2766, + "serialized_bytes": 611, + "statement_ns": 299559, + "success": true + }, + { + "mutex_wait_ns": 522484, + "serialization_ns": 2245, + "serialized_bytes": 613, + "statement_ns": 388044, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2474, + "serialized_bytes": 613, + "statement_ns": 291895, + "success": true + }, + { + "mutex_wait_ns": 695747, + "serialization_ns": 3116, + "serialized_bytes": 1036, + "statement_ns": 315799, + "success": true + }, + { + "mutex_wait_ns": 323793, + "serialization_ns": 3347, + "serialized_bytes": 1040, + "statement_ns": 394286, + "success": true + }, + { + "mutex_wait_ns": 401419, + "serialization_ns": 3356, + "serialized_bytes": 1075, + "statement_ns": 321359, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3466, + "serialized_bytes": 1083, + "statement_ns": 295712, + "success": true + }, + { + "mutex_wait_ns": 631909, + "serialization_ns": 3917, + "serialized_bytes": 1079, + "statement_ns": 351646, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3827, + "serialized_bytes": 1087, + "statement_ns": 298597, + "success": true + }, + { + "mutex_wait_ns": 666653, + "serialization_ns": 3457, + "serialized_bytes": 1298, + "statement_ns": 384828, + "success": true + }, + { + "mutex_wait_ns": 392973, + "serialization_ns": 3818, + "serialized_bytes": 1302, + "statement_ns": 350984, + "success": true + }, + { + "mutex_wait_ns": 257050, + "serialization_ns": 1984, + "serialized_bytes": 613, + "statement_ns": 339813, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2274, + "serialized_bytes": 613, + "statement_ns": 325106, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3155, + "serialized_bytes": 1040, + "statement_ns": 334423, + "success": true + }, + { + "mutex_wait_ns": 919816, + "serialization_ns": 2054, + "serialized_bytes": 613, + "statement_ns": 497738, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2384, + "serialized_bytes": 613, + "statement_ns": 360763, + "success": true + }, + { + "mutex_wait_ns": 873399, + "serialization_ns": 3547, + "serialized_bytes": 1079, + "statement_ns": 359911, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3847, + "serialized_bytes": 1087, + "statement_ns": 302664, + "success": true + }, + { + "mutex_wait_ns": 681331, + "serialization_ns": 3286, + "serialized_bytes": 1040, + "statement_ns": 337309, + "success": true + }, + { + "mutex_wait_ns": 344552, + "serialization_ns": 3778, + "serialized_bytes": 1302, + "statement_ns": 337540, + "success": true + }, + { + "mutex_wait_ns": 344382, + "serialization_ns": 3496, + "serialized_bytes": 1079, + "statement_ns": 388064, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3677, + "serialized_bytes": 1087, + "statement_ns": 312563, + "success": true + }, + { + "mutex_wait_ns": 601501, + "serialization_ns": 4339, + "serialized_bytes": 611, + "statement_ns": 331318, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2164, + "serialized_bytes": 611, + "statement_ns": 320177, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2926, + "serialized_bytes": 1036, + "statement_ns": 307804, + "success": true + }, + { + "mutex_wait_ns": 986610, + "serialization_ns": 3697, + "serialized_bytes": 1302, + "statement_ns": 307935, + "success": true + }, + { + "mutex_wait_ns": 315278, + "serialization_ns": 2935, + "serialized_bytes": 1075, + "statement_ns": 333022, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3627, + "serialized_bytes": 1083, + "statement_ns": 303687, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3798, + "serialized_bytes": 1298, + "statement_ns": 347759, + "success": true + }, + { + "mutex_wait_ns": 910792, + "serialization_ns": 2174, + "serialized_bytes": 611, + "statement_ns": 350293, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2875, + "serialized_bytes": 611, + "statement_ns": 287877, + "success": true + }, + { + "mutex_wait_ns": 540879, + "serialization_ns": 2234, + "serialized_bytes": 613, + "statement_ns": 329956, + "success": true + }, + { + "mutex_wait_ns": 338872, + "serialization_ns": 3176, + "serialized_bytes": 1036, + "statement_ns": 381240, + "success": true + }, + { + "mutex_wait_ns": 385409, + "serialization_ns": 2294, + "serialized_bytes": 613, + "statement_ns": 307503, + "success": true + }, + { + "mutex_wait_ns": 313695, + "serialization_ns": 3306, + "serialized_bytes": 1075, + "statement_ns": 305710, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3507, + "serialized_bytes": 1083, + "statement_ns": 448476, + "success": true + }, + { + "mutex_wait_ns": 772080, + "serialization_ns": 3506, + "serialized_bytes": 1040, + "statement_ns": 310309, + "success": true + }, + { + "mutex_wait_ns": 317352, + "serialization_ns": 3797, + "serialized_bytes": 1298, + "statement_ns": 297766, + "success": true + }, + { + "mutex_wait_ns": 303987, + "serialization_ns": 3807, + "serialized_bytes": 1079, + "statement_ns": 349352, + "success": true + }, + { + "mutex_wait_ns": 254004, + "serialization_ns": 2004, + "serialized_bytes": 611, + "statement_ns": 343310, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2414, + "serialized_bytes": 611, + "statement_ns": 275254, + "success": true + }, + { + "mutex_wait_ns": 635776, + "serialization_ns": 4298, + "serialized_bytes": 1087, + "statement_ns": 378185, + "success": true + }, + { + "mutex_wait_ns": 387623, + "serialization_ns": 2965, + "serialized_bytes": 1036, + "statement_ns": 335987, + "success": true + }, + { + "mutex_wait_ns": 342809, + "serialization_ns": 3948, + "serialized_bytes": 1302, + "statement_ns": 378777, + "success": true + }, + { + "mutex_wait_ns": 385289, + "serialization_ns": 3306, + "serialized_bytes": 1075, + "statement_ns": 338251, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3436, + "serialized_bytes": 1083, + "statement_ns": 297545, + "success": true + }, + { + "mutex_wait_ns": 532723, + "serialization_ns": 1904, + "serialized_bytes": 613, + "statement_ns": 332520, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2174, + "serialized_bytes": 613, + "statement_ns": 341597, + "success": true + }, + { + "mutex_wait_ns": 688414, + "serialization_ns": 3566, + "serialized_bytes": 1298, + "statement_ns": 346577, + "success": true + }, + { + "mutex_wait_ns": 356515, + "serialization_ns": 3266, + "serialized_bytes": 1040, + "statement_ns": 418601, + "success": true + }, + { + "mutex_wait_ns": 209491, + "serialization_ns": 3216, + "serialized_bytes": 611, + "statement_ns": 380459, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2324, + "serialized_bytes": 611, + "statement_ns": 339684, + "success": true + }, + { + "mutex_wait_ns": 734760, + "serialization_ns": 3577, + "serialized_bytes": 1079, + "statement_ns": 389787, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3758, + "serialized_bytes": 1087, + "statement_ns": 396990, + "success": true + }, + { + "mutex_wait_ns": 804711, + "serialization_ns": 3427, + "serialized_bytes": 1036, + "statement_ns": 318574, + "success": true + }, + { + "mutex_wait_ns": 325166, + "serialization_ns": 3718, + "serialized_bytes": 1302, + "statement_ns": 390398, + "success": true + }, + { + "mutex_wait_ns": 396680, + "serialization_ns": 3636, + "serialized_bytes": 1075, + "statement_ns": 340936, + "success": true + }, + { + "mutex_wait_ns": 220442, + "serialization_ns": 2013, + "serialized_bytes": 613, + "statement_ns": 339763, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3506, + "serialized_bytes": 613, + "statement_ns": 291384, + "success": true + }, + { + "mutex_wait_ns": 651756, + "serialization_ns": 4418, + "serialized_bytes": 1083, + "statement_ns": 518216, + "success": true + }, + { + "mutex_wait_ns": 526552, + "serialization_ns": 3276, + "serialized_bytes": 1040, + "statement_ns": 335997, + "success": true + }, + { + "mutex_wait_ns": 343591, + "serialization_ns": 3927, + "serialized_bytes": 1298, + "statement_ns": 358880, + "success": true + }, + { + "mutex_wait_ns": 365302, + "serialization_ns": 3756, + "serialized_bytes": 1079, + "statement_ns": 341837, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3737, + "serialized_bytes": 1087, + "statement_ns": 393935, + "success": true + }, + { + "mutex_wait_ns": 621459, + "serialization_ns": 2115, + "serialized_bytes": 613, + "statement_ns": 370961, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2415, + "serialized_bytes": 613, + "statement_ns": 310970, + "success": true + }, + { + "mutex_wait_ns": 697340, + "serialization_ns": 3857, + "serialized_bytes": 1302, + "statement_ns": 354532, + "success": true + }, + { + "mutex_wait_ns": 364009, + "serialization_ns": 3406, + "serialized_bytes": 1040, + "statement_ns": 370060, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4969, + "serialized_bytes": 1079, + "statement_ns": 341077, + "success": true + }, + { + "mutex_wait_ns": 302916, + "serialization_ns": 2204, + "serialized_bytes": 613, + "statement_ns": 322391, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2836, + "serialized_bytes": 613, + "statement_ns": 268691, + "success": true + }, + { + "mutex_wait_ns": 608525, + "serialization_ns": 4819, + "serialized_bytes": 1087, + "statement_ns": 404675, + "success": true + }, + { + "mutex_wait_ns": 413181, + "serialization_ns": 3627, + "serialized_bytes": 1040, + "statement_ns": 356124, + "success": true + }, + { + "mutex_wait_ns": 363408, + "serialization_ns": 4368, + "serialized_bytes": 1302, + "statement_ns": 322882, + "success": true + }, + { + "mutex_wait_ns": 329374, + "serialization_ns": 3738, + "serialized_bytes": 1079, + "statement_ns": 325627, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4258, + "serialized_bytes": 1087, + "statement_ns": 295421, + "success": true + }, + { + "mutex_wait_ns": 491386, + "serialization_ns": 3617, + "serialized_bytes": 613, + "statement_ns": 386782, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2355, + "serialized_bytes": 613, + "statement_ns": 326449, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3236, + "serialized_bytes": 1040, + "statement_ns": 317061, + "success": true + }, + { + "mutex_wait_ns": 1056210, + "serialization_ns": 4058, + "serialized_bytes": 1302, + "statement_ns": 336978, + "success": true + }, + { + "mutex_wait_ns": 343450, + "serialization_ns": 3557, + "serialized_bytes": 1079, + "statement_ns": 375210, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3767, + "serialized_bytes": 1087, + "statement_ns": 301722, + "success": true + }, + { + "mutex_wait_ns": 555887, + "serialization_ns": 2324, + "serialized_bytes": 613, + "statement_ns": 317562, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2615, + "serialized_bytes": 613, + "statement_ns": 346426, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3407, + "serialized_bytes": 1040, + "statement_ns": 311100, + "success": true + }, + { + "mutex_wait_ns": 1001968, + "serialization_ns": 4108, + "serialized_bytes": 1302, + "statement_ns": 316991, + "success": true + }, + { + "mutex_wait_ns": 323333, + "serialization_ns": 3587, + "serialized_bytes": 1079, + "statement_ns": 357096, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3857, + "serialized_bytes": 1087, + "statement_ns": 292686, + "success": true + }, + { + "mutex_wait_ns": 533826, + "serialization_ns": 2023, + "serialized_bytes": 611, + "statement_ns": 395498, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3556, + "serialized_bytes": 611, + "statement_ns": 335115, + "success": true + }, + { + "mutex_wait_ns": 749387, + "serialization_ns": 4088, + "serialized_bytes": 1302, + "statement_ns": 402381, + "success": true + }, + { + "mutex_wait_ns": 411307, + "serialization_ns": 4729, + "serialized_bytes": 1036, + "statement_ns": 451953, + "success": true + }, + { + "mutex_wait_ns": 60, + "serialization_ns": 7343, + "serialized_bytes": 1075, + "statement_ns": 346817, + "success": true + }, + { + "mutex_wait_ns": 60, + "serialization_ns": 5440, + "serialized_bytes": 1083, + "statement_ns": 344101, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 6231, + "serialized_bytes": 1298, + "statement_ns": 367035, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 517455, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=1", + "COMPILER=gcc-11.4.0", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_PTHREADS", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "TLS", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 118561873, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 58407222, + 65712796, + 70002306, + 73278948, + 73936585, + 77791759, + 78816706, + 79429360, + 78841364, + 79327088, + 79308335, + 79281533, + 79456761, + 79075380, + 79004406, + 79179665, + 82699950, + 84089071, + 86792662, + 88133483, + 92227388, + 94907737, + 95441458, + 99162904, + 98765028, + 105758490, + 105726150, + 110398164, + 110248510, + 114281992, + 114632075, + 117782771 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 34027977, + 26795053, + 143277, + 153286, + 174215, + 117880, + 162593 + ], + "failures": 0, + "in_window_samples": 5, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 34027977, + "end_ns": 44332733, + "in_window": true, + "scheduled_ns": null, + "start_ns": 10304756, + "success": true + }, + { + "elapsed_ns": 26795053, + "end_ns": 81203488, + "in_window": true, + "scheduled_ns": null, + "start_ns": 54408435, + "success": true + }, + { + "elapsed_ns": 143277, + "end_ns": 91419362, + "in_window": true, + "scheduled_ns": null, + "start_ns": 91276085, + "success": true + }, + { + "elapsed_ns": 153286, + "end_ns": 101643480, + "in_window": true, + "scheduled_ns": null, + "start_ns": 101490194, + "success": true + }, + { + "elapsed_ns": 174215, + "end_ns": 111891283, + "in_window": true, + "scheduled_ns": null, + "start_ns": 111717068, + "success": true + }, + { + "elapsed_ns": 117880, + "end_ns": 122082560, + "in_window": false, + "scheduled_ns": null, + "start_ns": 121964680, + "success": true + }, + { + "elapsed_ns": 162593, + "end_ns": 132313691, + "in_window": false, + "scheduled_ns": null, + "start_ns": 132151098, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 1797813, + 54571548, + 1038079, + 1167641, + 1392637, + 1697511, + 782134, + 907879, + 1080406 + ], + "failures": 0, + "in_window_samples": 6, + "missed_periods": 5, + "samples": [ + { + "elapsed_ns": 1797813, + "end_ns": 13128283, + "in_window": true, + "scheduled_ns": 11330470, + "start_ns": 13128283, + "success": true + }, + { + "elapsed_ns": 54571548, + "end_ns": 75902018, + "in_window": true, + "scheduled_ns": 21330470, + "start_ns": 75902018, + "success": true + }, + { + "elapsed_ns": 1038079, + "end_ns": 82368549, + "in_window": true, + "scheduled_ns": 81330470, + "start_ns": 82368549, + "success": true + }, + { + "elapsed_ns": 1167641, + "end_ns": 92498111, + "in_window": true, + "scheduled_ns": 91330470, + "start_ns": 92498111, + "success": true + }, + { + "elapsed_ns": 1392637, + "end_ns": 102723107, + "in_window": true, + "scheduled_ns": 101330470, + "start_ns": 102723107, + "success": true + }, + { + "elapsed_ns": 1697511, + "end_ns": 113027981, + "in_window": true, + "scheduled_ns": 111330470, + "start_ns": 113027981, + "success": true + }, + { + "elapsed_ns": 782134, + "end_ns": 122112604, + "in_window": false, + "scheduled_ns": 121330470, + "start_ns": 122112604, + "success": true + }, + { + "elapsed_ns": 907879, + "end_ns": 132238349, + "in_window": false, + "scheduled_ns": 131330470, + "start_ns": 132238349, + "success": true + }, + { + "elapsed_ns": 1080406, + "end_ns": 142410876, + "in_window": false, + "scheduled_ns": 141330470, + "start_ns": 142410876, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 119903987, + "window_start_ns": 1342114 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 1, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 51, + "serialization_ns": 2785, + "serialized_bytes": 613, + "statement_ns": 454087, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2816, + "serialized_bytes": 613, + "statement_ns": 392331, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3697, + "serialized_bytes": 1040, + "statement_ns": 354911, + "success": true + }, + { + "mutex_wait_ns": 597565, + "serialization_ns": 2344, + "serialized_bytes": 613, + "statement_ns": 456191, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4007, + "serialized_bytes": 613, + "statement_ns": 343381, + "success": true + }, + { + "mutex_wait_ns": 818156, + "serialization_ns": 4939, + "serialized_bytes": 1079, + "statement_ns": 392001, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4158, + "serialized_bytes": 1087, + "statement_ns": 344783, + "success": true + }, + { + "mutex_wait_ns": 753686, + "serialization_ns": 4508, + "serialized_bytes": 1040, + "statement_ns": 388775, + "success": true + }, + { + "mutex_wait_ns": 398974, + "serialization_ns": 4268, + "serialized_bytes": 1302, + "statement_ns": 379739, + "success": true + }, + { + "mutex_wait_ns": 431274, + "serialization_ns": 4088, + "serialized_bytes": 1079, + "statement_ns": 411598, + "success": true + }, + { + "mutex_wait_ns": 90, + "serialization_ns": 6722, + "serialized_bytes": 1087, + "statement_ns": 433889, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 6302, + "serialized_bytes": 1302, + "statement_ns": 426616, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 2315, + "serialized_bytes": 613, + "statement_ns": 374308, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2785, + "serialized_bytes": 613, + "statement_ns": 387332, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3476, + "serialized_bytes": 1040, + "statement_ns": 375731, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4028, + "serialized_bytes": 1079, + "statement_ns": 354942, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 4388, + "serialized_bytes": 1087, + "statement_ns": 420814, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3937, + "serialized_bytes": 1302, + "statement_ns": 375019, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2013, + "serialized_bytes": 613, + "statement_ns": 420064, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2886, + "serialized_bytes": 613, + "statement_ns": 358098, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3717, + "serialized_bytes": 1040, + "statement_ns": 358228, + "success": true + }, + { + "mutex_wait_ns": 903636, + "serialization_ns": 3396, + "serialized_bytes": 613, + "statement_ns": 413511, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3637, + "serialized_bytes": 613, + "statement_ns": 564422, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 5029, + "serialized_bytes": 1040, + "statement_ns": 535449, + "success": true + }, + { + "mutex_wait_ns": 1548718, + "serialization_ns": 4749, + "serialized_bytes": 1079, + "statement_ns": 352187, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4268, + "serialized_bytes": 1087, + "statement_ns": 334724, + "success": true + }, + { + "mutex_wait_ns": 700347, + "serialization_ns": 8335, + "serialized_bytes": 1079, + "statement_ns": 423129, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5531, + "serialized_bytes": 1087, + "statement_ns": 343911, + "success": true + }, + { + "mutex_wait_ns": 791085, + "serialization_ns": 4017, + "serialized_bytes": 1302, + "statement_ns": 345344, + "success": true + }, + { + "mutex_wait_ns": 349883, + "serialization_ns": 4899, + "serialized_bytes": 1302, + "statement_ns": 433869, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 1994, + "serialized_bytes": 613, + "statement_ns": 380460, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4078, + "serialized_bytes": 613, + "statement_ns": 362807, + "success": true + }, + { + "mutex_wait_ns": 250958, + "serialization_ns": 2034, + "serialized_bytes": 613, + "statement_ns": 361103, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2304, + "serialized_bytes": 613, + "statement_ns": 322201, + "success": true + }, + { + "mutex_wait_ns": 697651, + "serialization_ns": 5350, + "serialized_bytes": 1040, + "statement_ns": 372335, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4659, + "serialized_bytes": 1079, + "statement_ns": 330406, + "success": true + }, + { + "mutex_wait_ns": 731464, + "serialization_ns": 3396, + "serialized_bytes": 1040, + "statement_ns": 348029, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3626, + "serialized_bytes": 1079, + "statement_ns": 396119, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3798, + "serialized_bytes": 1087, + "statement_ns": 349532, + "success": true + }, + { + "mutex_wait_ns": 1125850, + "serialization_ns": 5601, + "serialized_bytes": 1087, + "statement_ns": 381060, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5000, + "serialized_bytes": 1302, + "statement_ns": 350494, + "success": true + }, + { + "mutex_wait_ns": 759837, + "serialization_ns": 4037, + "serialized_bytes": 1302, + "statement_ns": 402621, + "success": true + }, + { + "mutex_wait_ns": 13845, + "serialization_ns": 3036, + "serialized_bytes": 613, + "statement_ns": 434661, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 2264, + "serialized_bytes": 613, + "statement_ns": 346256, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2635, + "serialized_bytes": 613, + "statement_ns": 322662, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 5410, + "serialized_bytes": 1040, + "statement_ns": 360472, + "success": true + }, + { + "mutex_wait_ns": 1058224, + "serialization_ns": 3596, + "serialized_bytes": 613, + "statement_ns": 332570, + "success": true + }, + { + "mutex_wait_ns": 340796, + "serialization_ns": 3647, + "serialized_bytes": 1079, + "statement_ns": 355112, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4198, + "serialized_bytes": 1087, + "statement_ns": 336548, + "success": true + }, + { + "mutex_wait_ns": 708432, + "serialization_ns": 4869, + "serialized_bytes": 1040, + "statement_ns": 326098, + "success": true + }, + { + "mutex_wait_ns": 335686, + "serialization_ns": 4048, + "serialized_bytes": 1302, + "statement_ns": 396769, + "success": true + }, + { + "mutex_wait_ns": 410245, + "serialization_ns": 4128, + "serialized_bytes": 1079, + "statement_ns": 346857, + "success": true + }, + { + "mutex_wait_ns": 280052, + "serialization_ns": 2204, + "serialized_bytes": 611, + "statement_ns": 406278, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2524, + "serialized_bytes": 611, + "statement_ns": 343180, + "success": true + }, + { + "mutex_wait_ns": 766510, + "serialization_ns": 5811, + "serialized_bytes": 1087, + "statement_ns": 332961, + "success": true + }, + { + "mutex_wait_ns": 345044, + "serialization_ns": 3346, + "serialized_bytes": 1036, + "statement_ns": 371843, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4198, + "serialized_bytes": 1075, + "statement_ns": 328813, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3696, + "serialized_bytes": 1083, + "statement_ns": 323003, + "success": true + }, + { + "mutex_wait_ns": 1053525, + "serialization_ns": 5320, + "serialized_bytes": 1302, + "statement_ns": 388023, + "success": true + }, + { + "mutex_wait_ns": 405095, + "serialization_ns": 3927, + "serialized_bytes": 1298, + "statement_ns": 338502, + "success": true + }, + { + "mutex_wait_ns": 240879, + "serialization_ns": 1984, + "serialized_bytes": 611, + "statement_ns": 363909, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3626, + "serialized_bytes": 611, + "statement_ns": 370581, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4338, + "serialized_bytes": 1036, + "statement_ns": 330767, + "success": true + }, + { + "mutex_wait_ns": 1017798, + "serialization_ns": 2224, + "serialized_bytes": 613, + "statement_ns": 614276, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2785, + "serialized_bytes": 613, + "statement_ns": 324806, + "success": true + }, + { + "mutex_wait_ns": 951715, + "serialization_ns": 4499, + "serialized_bytes": 1075, + "statement_ns": 336507, + "success": true + }, + { + "mutex_wait_ns": 362637, + "serialization_ns": 4468, + "serialized_bytes": 1040, + "statement_ns": 348890, + "success": true + }, + { + "mutex_wait_ns": 360071, + "serialization_ns": 5320, + "serialized_bytes": 1083, + "statement_ns": 341407, + "success": true + }, + { + "mutex_wait_ns": 352287, + "serialization_ns": 3767, + "serialized_bytes": 1079, + "statement_ns": 345695, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 4248, + "serialized_bytes": 1087, + "statement_ns": 337830, + "success": true + }, + { + "mutex_wait_ns": 698914, + "serialization_ns": 4378, + "serialized_bytes": 1298, + "statement_ns": 395166, + "success": true + }, + { + "mutex_wait_ns": 404234, + "serialization_ns": 3928, + "serialized_bytes": 1302, + "statement_ns": 380720, + "success": true + }, + { + "mutex_wait_ns": 303586, + "serialization_ns": 2094, + "serialized_bytes": 613, + "statement_ns": 393745, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3716, + "serialized_bytes": 613, + "statement_ns": 308114, + "success": true + }, + { + "mutex_wait_ns": 637910, + "serialization_ns": 2043, + "serialized_bytes": 611, + "statement_ns": 415105, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2585, + "serialized_bytes": 611, + "statement_ns": 322191, + "success": true + }, + { + "mutex_wait_ns": 751702, + "serialization_ns": 4478, + "serialized_bytes": 1040, + "statement_ns": 343641, + "success": true + }, + { + "mutex_wait_ns": 361554, + "serialization_ns": 3266, + "serialized_bytes": 1036, + "statement_ns": 333682, + "success": true + }, + { + "mutex_wait_ns": 344162, + "serialization_ns": 5009, + "serialized_bytes": 1079, + "statement_ns": 324766, + "success": true + }, + { + "mutex_wait_ns": 329876, + "serialization_ns": 5470, + "serialized_bytes": 1075, + "statement_ns": 353389, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3697, + "serialized_bytes": 1083, + "statement_ns": 338972, + "success": true + }, + { + "mutex_wait_ns": 711156, + "serialization_ns": 5350, + "serialized_bytes": 1087, + "statement_ns": 358038, + "success": true + }, + { + "mutex_wait_ns": 365952, + "serialization_ns": 4819, + "serialized_bytes": 1298, + "statement_ns": 352919, + "success": true + }, + { + "mutex_wait_ns": 367916, + "serialization_ns": 4578, + "serialized_bytes": 1302, + "statement_ns": 392492, + "success": true + }, + { + "mutex_wait_ns": 323884, + "serialization_ns": 2174, + "serialized_bytes": 613, + "statement_ns": 386130, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3326, + "serialized_bytes": 613, + "statement_ns": 333031, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3236, + "serialized_bytes": 1040, + "statement_ns": 332099, + "success": true + }, + { + "mutex_wait_ns": 976992, + "serialization_ns": 3076, + "serialized_bytes": 613, + "statement_ns": 384307, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2534, + "serialized_bytes": 613, + "statement_ns": 298447, + "success": true + }, + { + "mutex_wait_ns": 697711, + "serialization_ns": 3758, + "serialized_bytes": 1079, + "statement_ns": 305069, + "success": true + }, + { + "mutex_wait_ns": 314667, + "serialization_ns": 3356, + "serialized_bytes": 1040, + "statement_ns": 329194, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3577, + "serialized_bytes": 1079, + "statement_ns": 298226, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4188, + "serialized_bytes": 1087, + "statement_ns": 294219, + "success": true + }, + { + "mutex_wait_ns": 955152, + "serialization_ns": 3987, + "serialized_bytes": 1087, + "statement_ns": 328673, + "success": true + }, + { + "mutex_wait_ns": 338021, + "serialization_ns": 4007, + "serialized_bytes": 1302, + "statement_ns": 344292, + "success": true + }, + { + "mutex_wait_ns": 350604, + "serialization_ns": 5380, + "serialized_bytes": 1302, + "statement_ns": 370441, + "success": true + }, + { + "mutex_wait_ns": 180667, + "serialization_ns": 2675, + "serialized_bytes": 613, + "statement_ns": 376111, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2975, + "serialized_bytes": 613, + "statement_ns": 290642, + "success": true + }, + { + "mutex_wait_ns": 588868, + "serialization_ns": 2324, + "serialized_bytes": 613, + "statement_ns": 352057, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2545, + "serialized_bytes": 613, + "statement_ns": 314366, + "success": true + }, + { + "mutex_wait_ns": 683856, + "serialization_ns": 3055, + "serialized_bytes": 1040, + "statement_ns": 290371, + "success": true + }, + { + "mutex_wait_ns": 298787, + "serialization_ns": 3336, + "serialized_bytes": 1040, + "statement_ns": 302754, + "success": true + }, + { + "mutex_wait_ns": 309908, + "serialization_ns": 3456, + "serialized_bytes": 1079, + "statement_ns": 303145, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3687, + "serialized_bytes": 1087, + "statement_ns": 316480, + "success": true + }, + { + "mutex_wait_ns": 636276, + "serialization_ns": 3597, + "serialized_bytes": 1079, + "statement_ns": 332350, + "success": true + }, + { + "mutex_wait_ns": 340084, + "serialization_ns": 3777, + "serialized_bytes": 1302, + "statement_ns": 333613, + "success": true + }, + { + "mutex_wait_ns": 351415, + "serialization_ns": 4077, + "serialized_bytes": 1087, + "statement_ns": 556148, + "success": true + }, + { + "mutex_wait_ns": 475897, + "serialization_ns": 2074, + "serialized_bytes": 611, + "statement_ns": 431575, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2565, + "serialized_bytes": 611, + "statement_ns": 322051, + "success": true + }, + { + "mutex_wait_ns": 769655, + "serialization_ns": 4348, + "serialized_bytes": 1302, + "statement_ns": 322251, + "success": true + }, + { + "mutex_wait_ns": 331528, + "serialization_ns": 3326, + "serialized_bytes": 1036, + "statement_ns": 325778, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3687, + "serialized_bytes": 1075, + "statement_ns": 326980, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3587, + "serialized_bytes": 1083, + "statement_ns": 295642, + "success": true + }, + { + "mutex_wait_ns": 889458, + "serialization_ns": 2175, + "serialized_bytes": 613, + "statement_ns": 350885, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2545, + "serialized_bytes": 613, + "statement_ns": 292696, + "success": true + }, + { + "mutex_wait_ns": 659150, + "serialization_ns": 3827, + "serialized_bytes": 1298, + "statement_ns": 1681656, + "success": true + }, + { + "mutex_wait_ns": 1698548, + "serialization_ns": 3146, + "serialized_bytes": 1040, + "statement_ns": 369690, + "success": true + }, + { + "mutex_wait_ns": 297315, + "serialization_ns": 2174, + "serialized_bytes": 611, + "statement_ns": 410946, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2414, + "serialized_bytes": 611, + "statement_ns": 296122, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3336, + "serialized_bytes": 1036, + "statement_ns": 299047, + "success": true + }, + { + "mutex_wait_ns": 1031123, + "serialization_ns": 3707, + "serialized_bytes": 1079, + "statement_ns": 329755, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3877, + "serialized_bytes": 1087, + "statement_ns": 350895, + "success": true + }, + { + "mutex_wait_ns": 697070, + "serialization_ns": 3527, + "serialized_bytes": 1075, + "statement_ns": 326349, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3767, + "serialized_bytes": 1083, + "statement_ns": 333432, + "success": true + }, + { + "mutex_wait_ns": 676301, + "serialization_ns": 4048, + "serialized_bytes": 1302, + "statement_ns": 354681, + "success": true + }, + { + "mutex_wait_ns": 368517, + "serialization_ns": 3697, + "serialized_bytes": 1298, + "statement_ns": 336849, + "success": true + }, + { + "mutex_wait_ns": 272468, + "serialization_ns": 2174, + "serialized_bytes": 613, + "statement_ns": 347368, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2675, + "serialized_bytes": 613, + "statement_ns": 323012, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3297, + "serialized_bytes": 1040, + "statement_ns": 300941, + "success": true + }, + { + "mutex_wait_ns": 915978, + "serialization_ns": 2284, + "serialized_bytes": 613, + "statement_ns": 353499, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2505, + "serialized_bytes": 613, + "statement_ns": 343781, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3226, + "serialized_bytes": 1040, + "statement_ns": 302615, + "success": true + }, + { + "mutex_wait_ns": 1024922, + "serialization_ns": 3336, + "serialized_bytes": 1079, + "statement_ns": 303496, + "success": true + }, + { + "mutex_wait_ns": 310008, + "serialization_ns": 3637, + "serialized_bytes": 1079, + "statement_ns": 362987, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 4098, + "serialized_bytes": 1087, + "statement_ns": 303627, + "success": true + }, + { + "mutex_wait_ns": 687282, + "serialization_ns": 3827, + "serialized_bytes": 1087, + "statement_ns": 306201, + "success": true + }, + { + "mutex_wait_ns": 314096, + "serialization_ns": 3597, + "serialized_bytes": 1302, + "statement_ns": 362296, + "success": true + }, + { + "mutex_wait_ns": 370632, + "serialization_ns": 4067, + "serialized_bytes": 1302, + "statement_ns": 364349, + "success": true + }, + { + "mutex_wait_ns": 214500, + "serialization_ns": 2014, + "serialized_bytes": 611, + "statement_ns": 391740, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2375, + "serialized_bytes": 611, + "statement_ns": 293898, + "success": true + }, + { + "mutex_wait_ns": 593637, + "serialization_ns": 2265, + "serialized_bytes": 611, + "statement_ns": 322010, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2434, + "serialized_bytes": 611, + "statement_ns": 315519, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3376, + "serialized_bytes": 1036, + "statement_ns": 291974, + "success": true + }, + { + "mutex_wait_ns": 958117, + "serialization_ns": 3106, + "serialized_bytes": 1036, + "statement_ns": 291123, + "success": true + }, + { + "mutex_wait_ns": 297605, + "serialization_ns": 3798, + "serialized_bytes": 1075, + "statement_ns": 291754, + "success": true + }, + { + "mutex_wait_ns": 298506, + "serialization_ns": 3527, + "serialized_bytes": 1075, + "statement_ns": 334915, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3627, + "serialized_bytes": 1083, + "statement_ns": 295451, + "success": true + }, + { + "mutex_wait_ns": 650082, + "serialization_ns": 3937, + "serialized_bytes": 1083, + "statement_ns": 291194, + "success": true + }, + { + "mutex_wait_ns": 298526, + "serialization_ns": 3808, + "serialized_bytes": 1298, + "statement_ns": 3373872, + "success": true + }, + { + "mutex_wait_ns": 3389462, + "serialization_ns": 4188, + "serialized_bytes": 1298, + "statement_ns": 406879, + "success": true + }, + { + "mutex_wait_ns": 323603, + "serialization_ns": 2495, + "serialized_bytes": 613, + "statement_ns": 461621, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 2875, + "serialized_bytes": 613, + "statement_ns": 302584, + "success": true + }, + { + "mutex_wait_ns": 641777, + "serialization_ns": 2214, + "serialized_bytes": 611, + "statement_ns": 371934, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2424, + "serialized_bytes": 611, + "statement_ns": 308065, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3206, + "serialized_bytes": 1036, + "statement_ns": 312132, + "success": true + }, + { + "mutex_wait_ns": 1020373, + "serialization_ns": 3096, + "serialized_bytes": 1040, + "statement_ns": 305089, + "success": true + }, + { + "mutex_wait_ns": 312262, + "serialization_ns": 3236, + "serialized_bytes": 1075, + "statement_ns": 341647, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3707, + "serialized_bytes": 1083, + "statement_ns": 300069, + "success": true + }, + { + "mutex_wait_ns": 657516, + "serialization_ns": 3546, + "serialized_bytes": 1079, + "statement_ns": 297846, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3847, + "serialized_bytes": 1087, + "statement_ns": 328964, + "success": true + }, + { + "mutex_wait_ns": 645394, + "serialization_ns": 3737, + "serialized_bytes": 1298, + "statement_ns": 338471, + "success": true + }, + { + "mutex_wait_ns": 345485, + "serialization_ns": 3967, + "serialized_bytes": 1302, + "statement_ns": 387633, + "success": true + }, + { + "mutex_wait_ns": 248253, + "serialization_ns": 2124, + "serialized_bytes": 613, + "statement_ns": 406939, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2585, + "serialized_bytes": 613, + "statement_ns": 287917, + "success": true + }, + { + "mutex_wait_ns": 574541, + "serialization_ns": 2365, + "serialized_bytes": 611, + "statement_ns": 326249, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2685, + "serialized_bytes": 611, + "statement_ns": 340836, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3366, + "serialized_bytes": 1036, + "statement_ns": 307153, + "success": true + }, + { + "mutex_wait_ns": 1001608, + "serialization_ns": 3086, + "serialized_bytes": 1040, + "statement_ns": 340154, + "success": true + }, + { + "mutex_wait_ns": 347167, + "serialization_ns": 3577, + "serialized_bytes": 1075, + "statement_ns": 358219, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3727, + "serialized_bytes": 1083, + "statement_ns": 296393, + "success": true + }, + { + "mutex_wait_ns": 671031, + "serialization_ns": 3647, + "serialized_bytes": 1079, + "statement_ns": 323895, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3908, + "serialized_bytes": 1087, + "statement_ns": 343290, + "success": true + }, + { + "mutex_wait_ns": 684978, + "serialization_ns": 3727, + "serialized_bytes": 1298, + "statement_ns": 304097, + "success": true + }, + { + "mutex_wait_ns": 311741, + "serialization_ns": 4037, + "serialized_bytes": 1302, + "statement_ns": 388255, + "success": true + }, + { + "mutex_wait_ns": 255546, + "serialization_ns": 2115, + "serialized_bytes": 613, + "statement_ns": 367075, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3135, + "serialized_bytes": 613, + "statement_ns": 278941, + "success": true + }, + { + "mutex_wait_ns": 506264, + "serialization_ns": 2044, + "serialized_bytes": 613, + "statement_ns": 377063, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2554, + "serialized_bytes": 613, + "statement_ns": 335957, + "success": true + }, + { + "mutex_wait_ns": 729370, + "serialization_ns": 3497, + "serialized_bytes": 1040, + "statement_ns": 309838, + "success": true + }, + { + "mutex_wait_ns": 317933, + "serialization_ns": 3376, + "serialized_bytes": 1040, + "statement_ns": 315201, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 6422, + "serialized_bytes": 1079, + "statement_ns": 306402, + "success": true + }, + { + "mutex_wait_ns": 650884, + "serialization_ns": 3948, + "serialized_bytes": 1079, + "statement_ns": 311951, + "success": true + }, + { + "mutex_wait_ns": 323183, + "serialization_ns": 5400, + "serialized_bytes": 1087, + "statement_ns": 305690, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 6422, + "serialized_bytes": 1302, + "statement_ns": 289340, + "success": true + }, + { + "mutex_wait_ns": 625727, + "serialization_ns": 5651, + "serialized_bytes": 1087, + "statement_ns": 332019, + "success": true + }, + { + "mutex_wait_ns": 147004, + "serialization_ns": 2985, + "serialized_bytes": 611, + "statement_ns": 421166, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3597, + "serialized_bytes": 611, + "statement_ns": 319276, + "success": true + }, + { + "mutex_wait_ns": 759336, + "serialization_ns": 6292, + "serialized_bytes": 1302, + "statement_ns": 375831, + "success": true + }, + { + "mutex_wait_ns": 385089, + "serialization_ns": 4778, + "serialized_bytes": 1036, + "statement_ns": 392886, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 6472, + "serialized_bytes": 1075, + "statement_ns": 389867, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3948, + "serialized_bytes": 1083, + "statement_ns": 335045, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4177, + "serialized_bytes": 1298, + "statement_ns": 317933, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 575784, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=1", + "COMPILER=gcc-11.4.0", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_PTHREADS", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "TLS", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 116030218, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 51024543, + 54344700, + 63462700, + 63261180, + 71616504, + 72457126, + 74555544, + 76356214, + 76453314, + 76607572, + 77128774, + 76809523, + 76543202, + 76528058, + 79367594, + 79430115, + 83553000, + 84241860, + 87214138, + 88876128, + 91595685, + 94677879, + 94850280, + 97675264, + 99353414, + 101707394, + 104766465, + 107807311, + 107659685, + 110958874, + 112461165, + 115712639 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 35749394, + 23108909, + 153316, + 121707, + 132457, + 134561, + 132036 + ], + "failures": 0, + "in_window_samples": 5, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 35749394, + "end_ns": 46134973, + "in_window": true, + "scheduled_ns": null, + "start_ns": 10385579, + "success": true + }, + { + "elapsed_ns": 23108909, + "end_ns": 79328979, + "in_window": true, + "scheduled_ns": null, + "start_ns": 56220070, + "success": true + }, + { + "elapsed_ns": 153316, + "end_ns": 89561043, + "in_window": true, + "scheduled_ns": null, + "start_ns": 89407727, + "success": true + }, + { + "elapsed_ns": 121707, + "end_ns": 99753021, + "in_window": true, + "scheduled_ns": null, + "start_ns": 99631314, + "success": true + }, + { + "elapsed_ns": 132457, + "end_ns": 109962582, + "in_window": true, + "scheduled_ns": null, + "start_ns": 109830125, + "success": true + }, + { + "elapsed_ns": 134561, + "end_ns": 120171893, + "in_window": false, + "scheduled_ns": null, + "start_ns": 120037332, + "success": true + }, + { + "elapsed_ns": 132036, + "end_ns": 130376475, + "in_window": false, + "scheduled_ns": null, + "start_ns": 130244439, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 38329112, + 26868799, + 1096925, + 1094140, + 1083952, + 984582, + 922101, + 1151579, + 294952 + ], + "failures": 0, + "in_window_samples": 6, + "missed_periods": 5, + "samples": [ + { + "elapsed_ns": 38329112, + "end_ns": 50628277, + "in_window": true, + "scheduled_ns": 12299165, + "start_ns": 50628277, + "success": true + }, + { + "elapsed_ns": 26868799, + "end_ns": 79167964, + "in_window": true, + "scheduled_ns": 52299165, + "start_ns": 79167964, + "success": true + }, + { + "elapsed_ns": 1096925, + "end_ns": 83396090, + "in_window": true, + "scheduled_ns": 82299165, + "start_ns": 83396090, + "success": true + }, + { + "elapsed_ns": 1094140, + "end_ns": 93393305, + "in_window": true, + "scheduled_ns": 92299165, + "start_ns": 93393305, + "success": true + }, + { + "elapsed_ns": 1083952, + "end_ns": 103383117, + "in_window": true, + "scheduled_ns": 102299165, + "start_ns": 103383117, + "success": true + }, + { + "elapsed_ns": 984582, + "end_ns": 113283747, + "in_window": true, + "scheduled_ns": 112299165, + "start_ns": 113283747, + "success": true + }, + { + "elapsed_ns": 922101, + "end_ns": 123221266, + "in_window": false, + "scheduled_ns": 122299165, + "start_ns": 123221266, + "success": true + }, + { + "elapsed_ns": 1151579, + "end_ns": 133450744, + "in_window": false, + "scheduled_ns": 132299165, + "start_ns": 133450744, + "success": true + }, + { + "elapsed_ns": 294952, + "end_ns": 142594117, + "in_window": false, + "scheduled_ns": 142299165, + "start_ns": 142594117, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 118340717, + "window_start_ns": 2310499 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 2, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 40, + "serialization_ns": 2635, + "serialized_bytes": 613, + "statement_ns": 453115, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2635, + "serialized_bytes": 613, + "statement_ns": 348630, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3516, + "serialized_bytes": 1040, + "statement_ns": 354702, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3767, + "serialized_bytes": 1079, + "statement_ns": 331448, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4228, + "serialized_bytes": 1087, + "statement_ns": 312824, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4187, + "serialized_bytes": 1302, + "statement_ns": 328223, + "success": true + }, + { + "mutex_wait_ns": 50, + "serialization_ns": 2365, + "serialized_bytes": 611, + "statement_ns": 495113, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2475, + "serialized_bytes": 611, + "statement_ns": 338862, + "success": true + }, + { + "mutex_wait_ns": 739379, + "serialization_ns": 2414, + "serialized_bytes": 611, + "statement_ns": 356525, + "success": true + }, + { + "mutex_wait_ns": 386791, + "serialization_ns": 3256, + "serialized_bytes": 1036, + "statement_ns": 337750, + "success": true + }, + { + "mutex_wait_ns": 319246, + "serialization_ns": 2404, + "serialized_bytes": 611, + "statement_ns": 307703, + "success": true + }, + { + "mutex_wait_ns": 314026, + "serialization_ns": 3386, + "serialized_bytes": 1075, + "statement_ns": 328061, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4588, + "serialized_bytes": 1083, + "statement_ns": 324796, + "success": true + }, + { + "mutex_wait_ns": 673436, + "serialization_ns": 3687, + "serialized_bytes": 1036, + "statement_ns": 313395, + "success": true + }, + { + "mutex_wait_ns": 320798, + "serialization_ns": 3867, + "serialized_bytes": 1298, + "statement_ns": 368608, + "success": true + }, + { + "mutex_wait_ns": 379548, + "serialization_ns": 3557, + "serialized_bytes": 1075, + "statement_ns": 353058, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3847, + "serialized_bytes": 1083, + "statement_ns": 324305, + "success": true + }, + { + "mutex_wait_ns": 333041, + "serialization_ns": 2104, + "serialized_bytes": 613, + "statement_ns": 404394, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2665, + "serialized_bytes": 613, + "statement_ns": 291634, + "success": true + }, + { + "mutex_wait_ns": 711006, + "serialization_ns": 3797, + "serialized_bytes": 1298, + "statement_ns": 325487, + "success": true + }, + { + "mutex_wait_ns": 333542, + "serialization_ns": 3307, + "serialized_bytes": 1040, + "statement_ns": 334223, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3757, + "serialized_bytes": 1079, + "statement_ns": 321590, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4058, + "serialized_bytes": 1087, + "statement_ns": 305349, + "success": true + }, + { + "mutex_wait_ns": 249796, + "serialization_ns": 2204, + "serialized_bytes": 613, + "statement_ns": 341547, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2555, + "serialized_bytes": 613, + "statement_ns": 332049, + "success": true + }, + { + "mutex_wait_ns": 689116, + "serialization_ns": 4508, + "serialized_bytes": 1302, + "statement_ns": 295350, + "success": true + }, + { + "mutex_wait_ns": 303947, + "serialization_ns": 3707, + "serialized_bytes": 1040, + "statement_ns": 633120, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 4107, + "serialized_bytes": 1079, + "statement_ns": 2479765, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4037, + "serialized_bytes": 1087, + "statement_ns": 409243, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4107, + "serialized_bytes": 1302, + "statement_ns": 370732, + "success": true + }, + { + "mutex_wait_ns": 3851373, + "serialization_ns": 1934, + "serialized_bytes": 613, + "statement_ns": 369329, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2735, + "serialized_bytes": 613, + "statement_ns": 343350, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3446, + "serialized_bytes": 1040, + "statement_ns": 312443, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3196, + "serialized_bytes": 1079, + "statement_ns": 413972, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4258, + "serialized_bytes": 1087, + "statement_ns": 334925, + "success": true + }, + { + "mutex_wait_ns": 84077, + "serialization_ns": 2084, + "serialized_bytes": 613, + "statement_ns": 345594, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 2435, + "serialized_bytes": 613, + "statement_ns": 308836, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3607, + "serialized_bytes": 1040, + "statement_ns": 321730, + "success": true + }, + { + "mutex_wait_ns": 1001728, + "serialization_ns": 4177, + "serialized_bytes": 1302, + "statement_ns": 307534, + "success": true + }, + { + "mutex_wait_ns": 313254, + "serialization_ns": 4057, + "serialized_bytes": 1079, + "statement_ns": 338432, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4088, + "serialized_bytes": 1087, + "statement_ns": 347538, + "success": true + }, + { + "mutex_wait_ns": 623272, + "serialization_ns": 2194, + "serialized_bytes": 613, + "statement_ns": 363548, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2494, + "serialized_bytes": 613, + "statement_ns": 345986, + "success": true + }, + { + "mutex_wait_ns": 723168, + "serialization_ns": 4008, + "serialized_bytes": 1302, + "statement_ns": 354041, + "success": true + }, + { + "mutex_wait_ns": 363889, + "serialization_ns": 3256, + "serialized_bytes": 1040, + "statement_ns": 342578, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3437, + "serialized_bytes": 1079, + "statement_ns": 329665, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3727, + "serialized_bytes": 1087, + "statement_ns": 303055, + "success": true + }, + { + "mutex_wait_ns": 906761, + "serialization_ns": 5140, + "serialized_bytes": 613, + "statement_ns": 341287, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2575, + "serialized_bytes": 613, + "statement_ns": 295892, + "success": true + }, + { + "mutex_wait_ns": 651265, + "serialization_ns": 3967, + "serialized_bytes": 1302, + "statement_ns": 313514, + "success": true + }, + { + "mutex_wait_ns": 322150, + "serialization_ns": 3236, + "serialized_bytes": 1040, + "statement_ns": 363949, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3527, + "serialized_bytes": 1079, + "statement_ns": 341436, + "success": true + }, + { + "mutex_wait_ns": 647628, + "serialization_ns": 2254, + "serialized_bytes": 611, + "statement_ns": 422408, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2444, + "serialized_bytes": 611, + "statement_ns": 340825, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3266, + "serialized_bytes": 1036, + "statement_ns": 294680, + "success": true + }, + { + "mutex_wait_ns": 1086486, + "serialization_ns": 3928, + "serialized_bytes": 1087, + "statement_ns": 307428, + "success": true + }, + { + "mutex_wait_ns": 317805, + "serialization_ns": 3407, + "serialized_bytes": 1075, + "statement_ns": 348667, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3998, + "serialized_bytes": 1083, + "statement_ns": 291635, + "success": true + }, + { + "mutex_wait_ns": 658483, + "serialization_ns": 5330, + "serialized_bytes": 1302, + "statement_ns": 334885, + "success": true + }, + { + "mutex_wait_ns": 341908, + "serialization_ns": 3687, + "serialized_bytes": 1298, + "statement_ns": 340304, + "success": true + }, + { + "mutex_wait_ns": 258973, + "serialization_ns": 2053, + "serialized_bytes": 613, + "statement_ns": 324395, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3035, + "serialized_bytes": 613, + "statement_ns": 286865, + "success": true + }, + { + "mutex_wait_ns": 257400, + "serialization_ns": 2004, + "serialized_bytes": 611, + "statement_ns": 405146, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2405, + "serialized_bytes": 611, + "statement_ns": 348670, + "success": true + }, + { + "mutex_wait_ns": 770497, + "serialization_ns": 3336, + "serialized_bytes": 1040, + "statement_ns": 675470, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3547, + "serialized_bytes": 1079, + "statement_ns": 349942, + "success": true + }, + { + "mutex_wait_ns": 1048465, + "serialization_ns": 3106, + "serialized_bytes": 1036, + "statement_ns": 602975, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3527, + "serialized_bytes": 1075, + "statement_ns": 370270, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3827, + "serialized_bytes": 1083, + "statement_ns": 352086, + "success": true + }, + { + "mutex_wait_ns": 1358363, + "serialization_ns": 4028, + "serialized_bytes": 1087, + "statement_ns": 389817, + "success": true + }, + { + "mutex_wait_ns": 397492, + "serialization_ns": 3947, + "serialized_bytes": 1298, + "statement_ns": 362185, + "success": true + }, + { + "mutex_wait_ns": 369689, + "serialization_ns": 4228, + "serialized_bytes": 1302, + "statement_ns": 505253, + "success": true + }, + { + "mutex_wait_ns": 103092, + "serialization_ns": 2184, + "serialized_bytes": 613, + "statement_ns": 465068, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2885, + "serialized_bytes": 613, + "statement_ns": 352266, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3316, + "serialized_bytes": 1040, + "statement_ns": 343591, + "success": true + }, + { + "mutex_wait_ns": 803218, + "serialization_ns": 1943, + "serialized_bytes": 611, + "statement_ns": 363398, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 2674, + "serialized_bytes": 611, + "statement_ns": 335295, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3476, + "serialized_bytes": 1036, + "statement_ns": 338311, + "success": true + }, + { + "mutex_wait_ns": 1062812, + "serialization_ns": 3597, + "serialized_bytes": 1079, + "statement_ns": 353950, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3988, + "serialized_bytes": 1087, + "statement_ns": 402801, + "success": true + }, + { + "mutex_wait_ns": 772260, + "serialization_ns": 3807, + "serialized_bytes": 1075, + "statement_ns": 337680, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4048, + "serialized_bytes": 1083, + "statement_ns": 308756, + "success": true + }, + { + "mutex_wait_ns": 662205, + "serialization_ns": 4017, + "serialized_bytes": 1302, + "statement_ns": 397622, + "success": true + }, + { + "mutex_wait_ns": 411317, + "serialization_ns": 3948, + "serialized_bytes": 1298, + "statement_ns": 323433, + "success": true + }, + { + "mutex_wait_ns": 258762, + "serialization_ns": 2224, + "serialized_bytes": 611, + "statement_ns": 372315, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2334, + "serialized_bytes": 611, + "statement_ns": 304478, + "success": true + }, + { + "mutex_wait_ns": 611771, + "serialization_ns": 2013, + "serialized_bytes": 613, + "statement_ns": 345315, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2455, + "serialized_bytes": 613, + "statement_ns": 309417, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3397, + "serialized_bytes": 1040, + "statement_ns": 318644, + "success": true + }, + { + "mutex_wait_ns": 1000236, + "serialization_ns": 3266, + "serialized_bytes": 1036, + "statement_ns": 321930, + "success": true + }, + { + "mutex_wait_ns": 327842, + "serialization_ns": 3727, + "serialized_bytes": 1079, + "statement_ns": 324765, + "success": true + }, + { + "mutex_wait_ns": 331278, + "serialization_ns": 3376, + "serialized_bytes": 1075, + "statement_ns": 360672, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3586, + "serialized_bytes": 1083, + "statement_ns": 322230, + "success": true + }, + { + "mutex_wait_ns": 702390, + "serialization_ns": 3736, + "serialized_bytes": 1087, + "statement_ns": 313976, + "success": true + }, + { + "mutex_wait_ns": 320688, + "serialization_ns": 3767, + "serialized_bytes": 1298, + "statement_ns": 377845, + "success": true + }, + { + "mutex_wait_ns": 384266, + "serialization_ns": 4128, + "serialized_bytes": 1302, + "statement_ns": 336368, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2094, + "serialized_bytes": 611, + "statement_ns": 372765, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2284, + "serialized_bytes": 611, + "statement_ns": 322922, + "success": true + }, + { + "mutex_wait_ns": 657827, + "serialization_ns": 2084, + "serialized_bytes": 611, + "statement_ns": 354130, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2465, + "serialized_bytes": 611, + "statement_ns": 347418, + "success": true + }, + { + "mutex_wait_ns": 717709, + "serialization_ns": 3476, + "serialized_bytes": 1036, + "statement_ns": 314416, + "success": true + }, + { + "mutex_wait_ns": 323504, + "serialization_ns": 3095, + "serialized_bytes": 1036, + "statement_ns": 297915, + "success": true + }, + { + "mutex_wait_ns": 304238, + "serialization_ns": 3556, + "serialized_bytes": 1075, + "statement_ns": 368918, + "success": true + }, + { + "mutex_wait_ns": 375461, + "serialization_ns": 3516, + "serialized_bytes": 1075, + "statement_ns": 357787, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3457, + "serialized_bytes": 1083, + "statement_ns": 312563, + "success": true + }, + { + "mutex_wait_ns": 690377, + "serialization_ns": 3888, + "serialized_bytes": 1083, + "statement_ns": 315288, + "success": true + }, + { + "mutex_wait_ns": 322672, + "serialization_ns": 3847, + "serialized_bytes": 1298, + "statement_ns": 522665, + "success": true + }, + { + "mutex_wait_ns": 529488, + "serialization_ns": 4228, + "serialized_bytes": 1298, + "statement_ns": 433058, + "success": true + }, + { + "mutex_wait_ns": 301292, + "serialization_ns": 2405, + "serialized_bytes": 613, + "statement_ns": 378045, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2445, + "serialized_bytes": 613, + "statement_ns": 338321, + "success": true + }, + { + "mutex_wait_ns": 611149, + "serialization_ns": 2104, + "serialized_bytes": 613, + "statement_ns": 378486, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2435, + "serialized_bytes": 613, + "statement_ns": 303426, + "success": true + }, + { + "mutex_wait_ns": 698082, + "serialization_ns": 3256, + "serialized_bytes": 1040, + "statement_ns": 357146, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3777, + "serialized_bytes": 1079, + "statement_ns": 305991, + "success": true + }, + { + "mutex_wait_ns": 684968, + "serialization_ns": 3336, + "serialized_bytes": 1040, + "statement_ns": 300911, + "success": true + }, + { + "mutex_wait_ns": 310549, + "serialization_ns": 3897, + "serialized_bytes": 1087, + "statement_ns": 320107, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3948, + "serialized_bytes": 1302, + "statement_ns": 344283, + "success": true + }, + { + "mutex_wait_ns": 682663, + "serialization_ns": 3737, + "serialized_bytes": 1079, + "statement_ns": 315669, + "success": true + }, + { + "mutex_wait_ns": 150171, + "serialization_ns": 3005, + "serialized_bytes": 613, + "statement_ns": 356264, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 2325, + "serialized_bytes": 613, + "statement_ns": 297195, + "success": true + }, + { + "mutex_wait_ns": 670470, + "serialization_ns": 4408, + "serialized_bytes": 1087, + "statement_ns": 311050, + "success": true + }, + { + "mutex_wait_ns": 319947, + "serialization_ns": 3015, + "serialized_bytes": 1040, + "statement_ns": 362426, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3537, + "serialized_bytes": 1079, + "statement_ns": 307473, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3937, + "serialized_bytes": 1087, + "statement_ns": 304789, + "success": true + }, + { + "mutex_wait_ns": 1004965, + "serialization_ns": 4057, + "serialized_bytes": 1302, + "statement_ns": 345394, + "success": true + }, + { + "mutex_wait_ns": 352858, + "serialization_ns": 3827, + "serialized_bytes": 1302, + "statement_ns": 377725, + "success": true + }, + { + "mutex_wait_ns": 283329, + "serialization_ns": 2194, + "serialized_bytes": 613, + "statement_ns": 385308, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2234, + "serialized_bytes": 613, + "statement_ns": 378626, + "success": true + }, + { + "mutex_wait_ns": 621298, + "serialization_ns": 1994, + "serialized_bytes": 613, + "statement_ns": 368688, + "success": true + }, + { + "mutex_wait_ns": 377956, + "serialization_ns": 3346, + "serialized_bytes": 1040, + "statement_ns": 321800, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4328, + "serialized_bytes": 1079, + "statement_ns": 348951, + "success": true + }, + { + "mutex_wait_ns": 41, + "serialization_ns": 3697, + "serialized_bytes": 1087, + "statement_ns": 306231, + "success": true + }, + { + "mutex_wait_ns": 1010685, + "serialization_ns": 2044, + "serialized_bytes": 613, + "statement_ns": 352998, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 3175, + "serialized_bytes": 1040, + "statement_ns": 311731, + "success": true + }, + { + "mutex_wait_ns": 683885, + "serialization_ns": 3757, + "serialized_bytes": 1302, + "statement_ns": 319066, + "success": true + }, + { + "mutex_wait_ns": 325677, + "serialization_ns": 3417, + "serialized_bytes": 1079, + "statement_ns": 337910, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4208, + "serialized_bytes": 1087, + "statement_ns": 318594, + "success": true + }, + { + "mutex_wait_ns": 578849, + "serialization_ns": 2245, + "serialized_bytes": 613, + "statement_ns": 359761, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2404, + "serialized_bytes": 613, + "statement_ns": 322472, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 4338, + "serialized_bytes": 1040, + "statement_ns": 310610, + "success": true + }, + { + "mutex_wait_ns": 1030001, + "serialization_ns": 3797, + "serialized_bytes": 1302, + "statement_ns": 350464, + "success": true + }, + { + "mutex_wait_ns": 356955, + "serialization_ns": 3447, + "serialized_bytes": 1079, + "statement_ns": 344833, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3828, + "serialized_bytes": 1087, + "statement_ns": 305360, + "success": true + }, + { + "mutex_wait_ns": 575544, + "serialization_ns": 1903, + "serialized_bytes": 613, + "statement_ns": 358108, + "success": true + }, + { + "mutex_wait_ns": 31, + "serialization_ns": 2294, + "serialized_bytes": 613, + "statement_ns": 355472, + "success": true + }, + { + "mutex_wait_ns": 727597, + "serialization_ns": 3686, + "serialized_bytes": 1302, + "statement_ns": 306472, + "success": true + }, + { + "mutex_wait_ns": 314857, + "serialization_ns": 3026, + "serialized_bytes": 1040, + "statement_ns": 351525, + "success": true + }, + { + "mutex_wait_ns": 262970, + "serialization_ns": 2044, + "serialized_bytes": 611, + "statement_ns": 353460, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2605, + "serialized_bytes": 611, + "statement_ns": 315659, + "success": true + }, + { + "mutex_wait_ns": 682693, + "serialization_ns": 3406, + "serialized_bytes": 1079, + "statement_ns": 364340, + "success": true + }, + { + "mutex_wait_ns": 29, + "serialization_ns": 3818, + "serialized_bytes": 1087, + "statement_ns": 522665, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3937, + "serialized_bytes": 1302, + "statement_ns": 465679, + "success": true + }, + { + "mutex_wait_ns": 1383841, + "serialization_ns": 3126, + "serialized_bytes": 1036, + "statement_ns": 417929, + "success": true + }, + { + "mutex_wait_ns": 188251, + "serialization_ns": 3687, + "serialized_bytes": 613, + "statement_ns": 348851, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2415, + "serialized_bytes": 613, + "statement_ns": 347759, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 3436, + "serialized_bytes": 1040, + "statement_ns": 310700, + "success": true + }, + { + "mutex_wait_ns": 1044298, + "serialization_ns": 4077, + "serialized_bytes": 1075, + "statement_ns": 306642, + "success": true + }, + { + "mutex_wait_ns": 312623, + "serialization_ns": 3827, + "serialized_bytes": 1079, + "statement_ns": 316981, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3788, + "serialized_bytes": 1087, + "statement_ns": 326558, + "success": true + }, + { + "mutex_wait_ns": 664941, + "serialization_ns": 4187, + "serialized_bytes": 1083, + "statement_ns": 307333, + "success": true + }, + { + "mutex_wait_ns": 314797, + "serialization_ns": 3777, + "serialized_bytes": 1302, + "statement_ns": 340736, + "success": true + }, + { + "mutex_wait_ns": 355904, + "serialization_ns": 4358, + "serialized_bytes": 1298, + "statement_ns": 375871, + "success": true + }, + { + "mutex_wait_ns": 295902, + "serialization_ns": 1873, + "serialized_bytes": 613, + "statement_ns": 350975, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2234, + "serialized_bytes": 613, + "statement_ns": 354291, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3066, + "serialized_bytes": 1040, + "statement_ns": 312943, + "success": true + }, + { + "mutex_wait_ns": 932098, + "serialization_ns": 2404, + "serialized_bytes": 613, + "statement_ns": 331468, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2585, + "serialized_bytes": 613, + "statement_ns": 337494, + "success": true + }, + { + "mutex_wait_ns": 686032, + "serialization_ns": 3356, + "serialized_bytes": 1079, + "statement_ns": 318713, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 3787, + "serialized_bytes": 1087, + "statement_ns": 321890, + "success": true + }, + { + "mutex_wait_ns": 657441, + "serialization_ns": 5110, + "serialized_bytes": 1040, + "statement_ns": 378316, + "success": true + }, + { + "mutex_wait_ns": 385409, + "serialization_ns": 4118, + "serialized_bytes": 1302, + "statement_ns": 333782, + "success": true + }, + { + "mutex_wait_ns": 339984, + "serialization_ns": 3927, + "serialized_bytes": 1079, + "statement_ns": 314657, + "success": true + }, + { + "mutex_wait_ns": 226893, + "serialization_ns": 1954, + "serialized_bytes": 613, + "statement_ns": 462543, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2695, + "serialized_bytes": 613, + "statement_ns": 335746, + "success": true + }, + { + "mutex_wait_ns": 816002, + "serialization_ns": 4509, + "serialized_bytes": 1087, + "statement_ns": 363468, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 4438, + "serialized_bytes": 1302, + "statement_ns": 344563, + "success": true + }, + { + "mutex_wait_ns": 729701, + "serialization_ns": 3176, + "serialized_bytes": 1040, + "statement_ns": 336006, + "success": true + }, + { + "mutex_wait_ns": 160970, + "serialization_ns": 2294, + "serialized_bytes": 611, + "statement_ns": 396760, + "success": true + }, + { + "mutex_wait_ns": 30, + "serialization_ns": 2615, + "serialized_bytes": 611, + "statement_ns": 331288, + "success": true + }, + { + "mutex_wait_ns": 741292, + "serialization_ns": 4438, + "serialized_bytes": 1079, + "statement_ns": 330447, + "success": true + }, + { + "mutex_wait_ns": 338691, + "serialization_ns": 3336, + "serialized_bytes": 1036, + "statement_ns": 332340, + "success": true + }, + { + "mutex_wait_ns": 342719, + "serialization_ns": 3918, + "serialized_bytes": 1087, + "statement_ns": 326689, + "success": true + }, + { + "mutex_wait_ns": 332430, + "serialization_ns": 3907, + "serialized_bytes": 1075, + "statement_ns": 330517, + "success": true + }, + { + "mutex_wait_ns": 337669, + "serialization_ns": 3817, + "serialized_bytes": 1302, + "statement_ns": 339784, + "success": true + }, + { + "mutex_wait_ns": 350524, + "serialization_ns": 3767, + "serialized_bytes": 1083, + "statement_ns": 344042, + "success": true + }, + { + "mutex_wait_ns": 205263, + "serialization_ns": 2054, + "serialized_bytes": 613, + "statement_ns": 437405, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 2434, + "serialized_bytes": 613, + "statement_ns": 338091, + "success": true + }, + { + "mutex_wait_ns": 792468, + "serialization_ns": 4699, + "serialized_bytes": 1298, + "statement_ns": 451502, + "success": true + }, + { + "mutex_wait_ns": 459377, + "serialization_ns": 4468, + "serialized_bytes": 1040, + "statement_ns": 390989, + "success": true + }, + { + "mutex_wait_ns": 60, + "serialization_ns": 6292, + "serialized_bytes": 1079, + "statement_ns": 361895, + "success": true + }, + { + "mutex_wait_ns": 40, + "serialization_ns": 7675, + "serialized_bytes": 1087, + "statement_ns": 326379, + "success": true + }, + { + "mutex_wait_ns": 60, + "serialization_ns": 29215, + "serialized_bytes": 1302, + "statement_ns": 333722, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 536781, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=1", + "COMPILER=gcc-11.4.0", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_PTHREADS", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "TLS", + "wall_budget_exceeded": false + } + ], + "not_run": { + "disk_flush_count": "not observed", + "gui_android": "outside harness", + "production_performance": "synthetic test-only harness", + "queue_wait": "no writer queue exists", + "sqlite_busy_wait_separate": "included in statement elapsed" + }, + "profile": "release", + "runtime": "multi_thread", + "schema": 1, + "status": "PASS", + "timer_network_positive_control": { + "reason": "intentional blocking control requires current-thread runtime", + "status": "NOTRUN" + }, + "workers": 2 + }, + "cleanup_uncertain": false + } + ], + "cleanup_uncertain": false +} diff --git a/docs/benchmarks/archive-responsiveness-2026-11-06-summary.json b/docs/benchmarks/archive-responsiveness-2026-11-06-summary.json new file mode 100644 index 0000000..4bc0dbd --- /dev/null +++ b/docs/benchmarks/archive-responsiveness-2026-11-06-summary.json @@ -0,0 +1,1337 @@ +{ + "schema": 1, + "source_commit": "19aec4fc8ca63551c05a0380c157c5593f048efa", + "run_id": 42293997874, + "run_url": "https://github.com/dalkedev/scope/actions/runs/42293997874", + "interpretation": "Descriptive synthetic samples only; profiles and operating systems remain separate; no disk/fsync or production improvement attribution.", + "statistics": "Per-batch phase totals, then min/median/max across three batches. Client/probe samples pooled only within one OS/profile/runtime/transport group; p95 is nearest rank. Probe samples must be in_window.", + "datasets": [ + { + "os": "Linux", + "file": "archive-responsiveness-2026-11-06-linux.json", + "sha256": "9ff56b40927d9e37cfc5fdc1f73b6fd333cd06d04c7038d9c9c23dd71be2f956", + "bytes": 1348272, + "metadata": { + "source_commit": "19aec4fc8ca63551c05a0380c157c5593f048efa", + "source_dirty": false, + "compiler": "rustc 1.99.1 (58cf8f9c3 2026-10-13)", + "os": "Linux", + "architecture": "x86_64", + "python": "3.12.16", + "hosted": { + "GITHUB_RUN_ID": "42293997874", + "GITHUB_RUN_ATTEMPT": "1", + "ImageOS": "ubuntu22", + "ImageVersion": "20261101.347.1" + }, + "resources": { + "logical_cpus": 4, + "affinity_cpus": 4, + "cgroup_memory_max_bytes": null, + "cgroup_cpu_quota_us": null, + "cgroup_cpu_period_us": null, + "peak_child_rss": "NOTRUN", + "filesystem_type": "NOTRUN", + "io_quota": "NOTRUN" + }, + "build_jobs": 2, + "profiles": [ + "debug", + "release" + ], + "workers": [ + 0, + 2 + ], + "samples_per_transport": 3, + "build_hard_timeout_s": 600, + "child_hard_timeout_s": 420, + "overall_budget_s": 1800, + "optimization": { + "debug": "repository profile: opt-level=0,debug=1", + "release": "repository profile: opt-level=3,lto=thin,strip=true" + }, + "profile_limits": "environment flag/profile/wrapper overrides rejected; user Cargo configuration is not inspected; hosted jobs use clean checkout and toolchain", + "storage": "OS temporary directory; fresh file-backed SQLite archive per case; path omitted", + "unavailable_resource_fields": "null means NOTRUN or not exposed by this platform" + } + }, + { + "os": "Windows", + "file": "archive-responsiveness-2026-11-06-windows.json", + "sha256": "b0bc098f1cc42dbcf1efbeb32fc5b67a581820e31b4b479d06d71a0009606dac", + "bytes": 1393416, + "metadata": { + "source_commit": "19aec4fc8ca63551c05a0380c157c5593f048efa", + "source_dirty": false, + "compiler": "rustc 1.99.1 (58cf8f9c3 2026-10-13)", + "os": "Windows", + "architecture": "AMD64", + "python": "3.12.10", + "hosted": { + "GITHUB_RUN_ID": "42293997874", + "GITHUB_RUN_ATTEMPT": "1", + "ImageOS": null, + "ImageVersion": null + }, + "resources": { + "logical_cpus": 4, + "affinity_cpus": null, + "cgroup_memory_max_bytes": null, + "cgroup_cpu_quota_us": null, + "cgroup_cpu_period_us": null, + "peak_child_rss": "NOTRUN", + "filesystem_type": "NOTRUN", + "io_quota": "NOTRUN" + }, + "build_jobs": 2, + "profiles": [ + "debug", + "release" + ], + "workers": [ + 0, + 2 + ], + "samples_per_transport": 3, + "build_hard_timeout_s": 600, + "child_hard_timeout_s": 420, + "overall_budget_s": 1800, + "optimization": { + "debug": "repository profile: opt-level=0,debug=1", + "release": "repository profile: opt-level=3,lto=thin,strip=true" + }, + "profile_limits": "environment flag/profile/wrapper overrides rejected; user Cargo configuration is not inspected; hosted jobs use clean checkout and toolchain", + "storage": "OS temporary directory; fresh file-backed SQLite archive per case; path omitted", + "unavailable_resource_fields": "null means NOTRUN or not exposed by this platform" + } + } + ], + "groups": [ + { + "os": "Linux", + "profile": "debug", + "workers": 0, + "transport": "HTTP", + "batches": 3, + "clients_successful": 96, + "persisted_rows": 96, + "successful_save_statements": 576, + "batch_ms": { + "n": 3, + "min": 110.792794, + "median": 121.559741, + "p95_nearest_rank": 123.572927, + "max": 123.572927 + }, + "client_ms": { + "n": 96, + "min": 105.23017, + "median": 117.32692399999999, + "p95_nearest_rank": 121.120102, + "max": 121.666742 + }, + "shutdown_ms": { + "n": 3, + "min": 2.832072, + "median": 2.886293, + "p95_nearest_rank": 3.843518, + "max": 3.843518 + }, + "probe_window_coverage_batches": { + "timer": 3, + "network": 3 + }, + "probe_failures_in_window": { + "timer": 0, + "network": 0 + }, + "control_status": "PASS", + "serialization_ms_per_batch_sum": { + "n": 3, + "min": 8.421571, + "median": 8.479403, + "p95_nearest_rank": 8.644987, + "max": 8.644987 + }, + "mutex_wait_ms_per_batch_sum": { + "n": 3, + "min": 0.043264, + "median": 0.043435, + "p95_nearest_rank": 0.044238, + "max": 0.044238 + }, + "statement_ms_per_batch_sum": { + "n": 3, + "min": 81.114637, + "median": 89.760661, + "p95_nearest_rank": 93.530943, + "max": 93.530943 + }, + "timer_ms_in_window": { + "n": 5, + "min": 1.529736, + "median": 98.882993, + "p95_nearest_rank": 111.691147, + "max": 111.691147 + }, + "network_ms_in_window": { + "n": 4, + "min": 0.694874, + "median": 99.147729, + "p95_nearest_rank": 111.414047, + "max": 111.414047 + } + }, + { + "os": "Linux", + "profile": "debug", + "workers": 0, + "transport": "TLS", + "batches": 3, + "clients_successful": 96, + "persisted_rows": 96, + "successful_save_statements": 576, + "batch_ms": { + "n": 3, + "min": 196.858699, + "median": 198.527471, + "p95_nearest_rank": 225.387423, + "max": 225.387423 + }, + "client_ms": { + "n": 96, + "min": 169.962646, + "median": 174.901142, + "p95_nearest_rank": 201.408111, + "max": 219.684967 + }, + "shutdown_ms": { + "n": 3, + "min": 1.995591, + "median": 2.024206, + "p95_nearest_rank": 2.031088, + "max": 2.031088 + }, + "probe_window_coverage_batches": { + "timer": 3, + "network": 3 + }, + "probe_failures_in_window": { + "timer": 0, + "network": 0 + }, + "control_status": "PASS", + "serialization_ms_per_batch_sum": { + "n": 3, + "min": 8.383525, + "median": 8.631174, + "p95_nearest_rank": 9.42046, + "max": 9.42046 + }, + "mutex_wait_ms_per_batch_sum": { + "n": 3, + "min": 0.044391, + "median": 0.051785, + "p95_nearest_rank": 0.069739, + "max": 0.069739 + }, + "statement_ms_per_batch_sum": { + "n": 3, + "min": 73.846576, + "median": 82.257895, + "p95_nearest_rank": 87.670585, + "max": 87.670585 + }, + "timer_ms_in_window": { + "n": 17, + "min": 0.364857, + "median": 13.580343, + "p95_nearest_rank": 96.627096, + "max": 96.627096 + }, + "network_ms_in_window": { + "n": 21, + "min": 0.149288, + "median": 5.188337, + "p95_nearest_rank": 83.848272, + "max": 85.469181 + } + }, + { + "os": "Linux", + "profile": "debug", + "workers": 2, + "transport": "HTTP", + "batches": 3, + "clients_successful": 96, + "persisted_rows": 96, + "successful_save_statements": 576, + "batch_ms": { + "n": 3, + "min": 84.755199, + "median": 85.189753, + "p95_nearest_rank": 87.917039, + "max": 87.917039 + }, + "client_ms": { + "n": 96, + "min": 19.240859, + "median": 80.616655, + "p95_nearest_rank": 85.546887, + "max": 86.506863 + }, + "shutdown_ms": { + "n": 3, + "min": 2.913494, + "median": 3.027426, + "p95_nearest_rank": 3.153561, + "max": 3.153561 + }, + "probe_window_coverage_batches": { + "timer": 3, + "network": 3 + }, + "probe_failures_in_window": { + "timer": 0, + "network": 0 + }, + "control_status": "NOTRUN", + "serialization_ms_per_batch_sum": { + "n": 3, + "min": 8.982542, + "median": 9.34041, + "p95_nearest_rank": 12.278159, + "max": 12.278159 + }, + "mutex_wait_ms_per_batch_sum": { + "n": 3, + "min": 55.956536, + "median": 56.219313, + "p95_nearest_rank": 56.459314, + "max": 56.459314 + }, + "statement_ms_per_batch_sum": { + "n": 3, + "min": 74.147271, + "median": 75.201, + "p95_nearest_rank": 77.674911, + "max": 77.674911 + }, + "timer_ms_in_window": { + "n": 9, + "min": 4.531464, + "median": 18.069815, + "p95_nearest_rank": 45.536244, + "max": 45.536244 + }, + "network_ms_in_window": { + "n": 5, + "min": 11.360849, + "median": 37.973934, + "p95_nearest_rank": 74.450574, + "max": 74.450574 + } + }, + { + "os": "Linux", + "profile": "debug", + "workers": 2, + "transport": "TLS", + "batches": 3, + "clients_successful": 96, + "persisted_rows": 96, + "successful_save_statements": 576, + "batch_ms": { + "n": 3, + "min": 140.938174, + "median": 146.341668, + "p95_nearest_rank": 193.332402, + "max": 193.332402 + }, + "client_ms": { + "n": 96, + "min": 67.286252, + "median": 118.2298885, + "p95_nearest_rank": 180.675767, + "max": 189.889643 + }, + "shutdown_ms": { + "n": 3, + "min": 1.905003, + "median": 1.997976, + "p95_nearest_rank": 2.054562, + "max": 2.054562 + }, + "probe_window_coverage_batches": { + "timer": 3, + "network": 3 + }, + "probe_failures_in_window": { + "timer": 0, + "network": 0 + }, + "control_status": "NOTRUN", + "serialization_ms_per_batch_sum": { + "n": 3, + "min": 8.682562, + "median": 9.088535, + "p95_nearest_rank": 9.164317, + "max": 9.164317 + }, + "mutex_wait_ms_per_batch_sum": { + "n": 3, + "min": 41.684575, + "median": 50.855206, + "p95_nearest_rank": 53.685758, + "max": 53.685758 + }, + "statement_ms_per_batch_sum": { + "n": 3, + "min": 78.640901, + "median": 79.135129, + "p95_nearest_rank": 84.133878, + "max": 84.133878 + }, + "timer_ms_in_window": { + "n": 27, + "min": 0.206002, + "median": 2.217467, + "p95_nearest_rank": 46.559073, + "max": 62.195997 + }, + "network_ms_in_window": { + "n": 20, + "min": 0.133238, + "median": 4.819744, + "p95_nearest_rank": 45.052806, + "max": 53.214357 + } + }, + { + "os": "Linux", + "profile": "release", + "workers": 0, + "transport": "HTTP", + "batches": 3, + "clients_successful": 96, + "persisted_rows": 96, + "successful_save_statements": 576, + "batch_ms": { + "n": 3, + "min": 69.674566, + "median": 74.937562, + "p95_nearest_rank": 82.818771, + "max": 82.818771 + }, + "client_ms": { + "n": 96, + "min": 68.07882, + "median": 74.03806900000001, + "p95_nearest_rank": 82.27168, + "max": 82.600062 + }, + "shutdown_ms": { + "n": 3, + "min": 0.9813, + "median": 1.003602, + "p95_nearest_rank": 1.046612, + "max": 1.046612 + }, + "probe_window_coverage_batches": { + "timer": 3, + "network": 3 + }, + "probe_failures_in_window": { + "timer": 0, + "network": 0 + }, + "control_status": "PASS", + "serialization_ms_per_batch_sum": { + "n": 3, + "min": 0.604026, + "median": 0.604986, + "p95_nearest_rank": 0.608606, + "max": 0.608606 + }, + "mutex_wait_ms_per_batch_sum": { + "n": 3, + "min": 0.00669, + "median": 0.006723, + "p95_nearest_rank": 0.006854, + "max": 0.006854 + }, + "statement_ms_per_batch_sum": { + "n": 3, + "min": 63.392218, + "median": 68.321466, + "p95_nearest_rank": 74.53068, + "max": 74.53068 + }, + "timer_ms_in_window": { + "n": 3, + "min": 59.488499, + "median": 64.746135, + "p95_nearest_rank": 72.614098, + "max": 72.614098 + }, + "network_ms_in_window": { + "n": 3, + "min": 60.26126, + "median": 65.468301, + "p95_nearest_rank": 74.382537, + "max": 74.382537 + } + }, + { + "os": "Linux", + "profile": "release", + "workers": 0, + "transport": "TLS", + "batches": 3, + "clients_successful": 96, + "persisted_rows": 96, + "successful_save_statements": 576, + "batch_ms": { + "n": 3, + "min": 121.759167, + "median": 131.552609, + "p95_nearest_rank": 157.093754, + "max": 157.093754 + }, + "client_ms": { + "n": 96, + "min": 88.809505, + "median": 101.4006985, + "p95_nearest_rank": 125.676719, + "max": 155.445399 + }, + "shutdown_ms": { + "n": 3, + "min": 0.48282, + "median": 0.538785, + "p95_nearest_rank": 0.585312, + "max": 0.585312 + }, + "probe_window_coverage_batches": { + "timer": 3, + "network": 3 + }, + "probe_failures_in_window": { + "timer": 0, + "network": 0 + }, + "control_status": "PASS", + "serialization_ms_per_batch_sum": { + "n": 3, + "min": 0.610542, + "median": 0.615829, + "p95_nearest_rank": 0.697681, + "max": 0.697681 + }, + "mutex_wait_ms_per_batch_sum": { + "n": 3, + "min": 0.00679, + "median": 0.006929, + "p95_nearest_rank": 0.007207, + "max": 0.007207 + }, + "statement_ms_per_batch_sum": { + "n": 3, + "min": 65.845819, + "median": 68.538232, + "p95_nearest_rank": 80.268721, + "max": 80.268721 + }, + "timer_ms_in_window": { + "n": 15, + "min": 0.382275, + "median": 1.525392, + "p95_nearest_rank": 71.974384, + "max": 71.974384 + }, + "network_ms_in_window": { + "n": 14, + "min": 0.116938, + "median": 0.177361, + "p95_nearest_rank": 76.538187, + "max": 76.538187 + } + }, + { + "os": "Linux", + "profile": "release", + "workers": 2, + "transport": "HTTP", + "batches": 3, + "clients_successful": 96, + "persisted_rows": 96, + "successful_save_statements": 576, + "batch_ms": { + "n": 3, + "min": 71.517624, + "median": 72.542836, + "p95_nearest_rank": 75.018829, + "max": 75.018829 + }, + "client_ms": { + "n": 96, + "min": 61.516431, + "median": 69.872967, + "p95_nearest_rank": 73.881897, + "max": 74.183809 + }, + "shutdown_ms": { + "n": 3, + "min": 0.929778, + "median": 1.074254, + "p95_nearest_rank": 1.090284, + "max": 1.090284 + }, + "probe_window_coverage_batches": { + "timer": 3, + "network": 3 + }, + "probe_failures_in_window": { + "timer": 0, + "network": 0 + }, + "control_status": "NOTRUN", + "serialization_ms_per_batch_sum": { + "n": 3, + "min": 0.669795, + "median": 0.772565, + "p95_nearest_rank": 0.929942, + "max": 0.929942 + }, + "mutex_wait_ms_per_batch_sum": { + "n": 3, + "min": 64.904937, + "median": 65.222348, + "p95_nearest_rank": 69.292447, + "max": 69.292447 + }, + "statement_ms_per_batch_sum": { + "n": 3, + "min": 66.960981, + "median": 68.052861, + "p95_nearest_rank": 71.009116, + "max": 71.009116 + }, + "timer_ms_in_window": { + "n": 7, + "min": 0.766182, + "median": 28.506115, + "p95_nearest_rank": 48.923097, + "max": 48.923097 + }, + "network_ms_in_window": { + "n": 4, + "min": 1.708476, + "median": 54.445869, + "p95_nearest_rank": 63.886992, + "max": 63.886992 + } + }, + { + "os": "Linux", + "profile": "release", + "workers": 2, + "transport": "TLS", + "batches": 3, + "clients_successful": 96, + "persisted_rows": 96, + "successful_save_statements": 576, + "batch_ms": { + "n": 3, + "min": 116.030218, + "median": 118.561873, + "p95_nearest_rank": 153.055054, + "max": 153.055054 + }, + "client_ms": { + "n": 96, + "min": 51.024543, + "median": 98.220146, + "p95_nearest_rank": 143.522807, + "max": 152.078543 + }, + "shutdown_ms": { + "n": 3, + "min": 0.517455, + "median": 0.536781, + "p95_nearest_rank": 0.575784, + "max": 0.575784 + }, + "probe_window_coverage_batches": { + "timer": 3, + "network": 3 + }, + "probe_failures_in_window": { + "timer": 0, + "network": 0 + }, + "control_status": "NOTRUN", + "serialization_ms_per_batch_sum": { + "n": 3, + "min": 0.670006, + "median": 0.702549, + "p95_nearest_rank": 0.758495, + "max": 0.758495 + }, + "mutex_wait_ms_per_batch_sum": { + "n": 3, + "min": 55.226283, + "median": 60.799116, + "p95_nearest_rank": 63.465332, + "max": 63.465332 + }, + "statement_ms_per_batch_sum": { + "n": 3, + "min": 65.547336, + "median": 69.673661, + "p95_nearest_rank": 71.989646, + "max": 71.989646 + }, + "timer_ms_in_window": { + "n": 20, + "min": 0.984582, + "median": 1.280139, + "p95_nearest_rank": 38.329112, + "max": 54.571548 + }, + "network_ms_in_window": { + "n": 17, + "min": 0.11257, + "median": 0.174215, + "p95_nearest_rank": 35.749394, + "max": 35.749394 + } + }, + { + "os": "Windows", + "profile": "debug", + "workers": 0, + "transport": "HTTP", + "batches": 3, + "clients_successful": 96, + "persisted_rows": 96, + "successful_save_statements": 576, + "batch_ms": { + "n": 3, + "min": 651.9128, + "median": 673.2964, + "p95_nearest_rank": 753.713, + "max": 753.713 + }, + "client_ms": { + "n": 96, + "min": 644.4864, + "median": 668.4947999999999, + "p95_nearest_rank": 750.433, + "max": 751.9358 + }, + "shutdown_ms": { + "n": 3, + "min": 2.8253, + "median": 3.3211, + "p95_nearest_rank": 3.6556, + "max": 3.6556 + }, + "probe_window_coverage_batches": { + "timer": 3, + "network": 3 + }, + "probe_failures_in_window": { + "timer": 0, + "network": 0 + }, + "control_status": "PASS", + "serialization_ms_per_batch_sum": { + "n": 3, + "min": 8.8091, + "median": 8.9748, + "p95_nearest_rank": 9.0825, + "max": 9.0825 + }, + "mutex_wait_ms_per_batch_sum": { + "n": 3, + "min": 0.0429, + "median": 0.043, + "p95_nearest_rank": 0.0452, + "max": 0.0452 + }, + "statement_ms_per_batch_sum": { + "n": 3, + "min": 615.2838, + "median": 636.3013, + "p95_nearest_rank": 714.8458, + "max": 714.8458 + }, + "timer_ms_in_window": { + "n": 5, + "min": 0.8816, + "median": 639.1408, + "p95_nearest_rank": 731.9699, + "max": 731.9699 + }, + "network_ms_in_window": { + "n": 6, + "min": 6.0255, + "median": 325.69944999999996, + "p95_nearest_rank": 731.1173, + "max": 731.1173 + } + }, + { + "os": "Windows", + "profile": "debug", + "workers": 0, + "transport": "TLS", + "batches": 3, + "clients_successful": 96, + "persisted_rows": 96, + "successful_save_statements": 576, + "batch_ms": { + "n": 3, + "min": 725.3956, + "median": 749.6946, + "p95_nearest_rank": 851.9789, + "max": 851.9789 + }, + "client_ms": { + "n": 96, + "min": 714.8191, + "median": 744.229, + "p95_nearest_rank": 849.2818, + "max": 849.9925 + }, + "shutdown_ms": { + "n": 3, + "min": 1.763, + "median": 2.1086, + "p95_nearest_rank": 2.1242, + "max": 2.1242 + }, + "probe_window_coverage_batches": { + "timer": 3, + "network": 3 + }, + "probe_failures_in_window": { + "timer": 0, + "network": 0 + }, + "control_status": "PASS", + "serialization_ms_per_batch_sum": { + "n": 3, + "min": 8.7239, + "median": 8.752, + "p95_nearest_rank": 9.1119, + "max": 9.1119 + }, + "mutex_wait_ms_per_batch_sum": { + "n": 3, + "min": 0.0437, + "median": 0.0446, + "p95_nearest_rank": 0.0468, + "max": 0.0468 + }, + "statement_ms_per_batch_sum": { + "n": 3, + "min": 585.0123, + "median": 613.3022, + "p95_nearest_rank": 666.9243, + "max": 666.9243 + }, + "timer_ms_in_window": { + "n": 12, + "min": 5.9407, + "median": 47.9945, + "p95_nearest_rank": 670.2275, + "max": 670.2275 + }, + "network_ms_in_window": { + "n": 18, + "min": 1.541, + "median": 24.602800000000002, + "p95_nearest_rank": 666.4201, + "max": 666.4201 + } + }, + { + "os": "Windows", + "profile": "debug", + "workers": 2, + "transport": "HTTP", + "batches": 3, + "clients_successful": 96, + "persisted_rows": 96, + "successful_save_statements": 576, + "batch_ms": { + "n": 3, + "min": 643.0824, + "median": 648.2988, + "p95_nearest_rank": 721.8238, + "max": 721.8238 + }, + "client_ms": { + "n": 96, + "min": 102.0302, + "median": 638.2235499999999, + "p95_nearest_rank": 717.1158, + "max": 718.1045 + }, + "shutdown_ms": { + "n": 3, + "min": 3.8204, + "median": 3.8985, + "p95_nearest_rank": 4.0645, + "max": 4.0645 + }, + "probe_window_coverage_batches": { + "timer": 3, + "network": 3 + }, + "probe_failures_in_window": { + "timer": 0, + "network": 0 + }, + "control_status": "NOTRUN", + "serialization_ms_per_batch_sum": { + "n": 3, + "min": 9.6244, + "median": 9.809, + "p95_nearest_rank": 10.1978, + "max": 10.1978 + }, + "mutex_wait_ms_per_batch_sum": { + "n": 3, + "min": 605.0095, + "median": 606.9832, + "p95_nearest_rank": 681.134, + "max": 681.134 + }, + "statement_ms_per_batch_sum": { + "n": 3, + "min": 628.9808, + "median": 637.7595, + "p95_nearest_rank": 709.6442, + "max": 709.6442 + }, + "timer_ms_in_window": { + "n": 9, + "min": 0.7429, + "median": 221.8965, + "p95_nearest_rank": 407.3969, + "max": 407.3969 + }, + "network_ms_in_window": { + "n": 9, + "min": 0.6611, + "median": 125.6057, + "p95_nearest_rank": 629.2787, + "max": 629.2787 + } + }, + { + "os": "Windows", + "profile": "debug", + "workers": 2, + "transport": "TLS", + "batches": 3, + "clients_successful": 96, + "persisted_rows": 96, + "successful_save_statements": 576, + "batch_ms": { + "n": 3, + "min": 675.9434, + "median": 717.3475, + "p95_nearest_rank": 723.6809, + "max": 723.6809 + }, + "client_ms": { + "n": 96, + "min": 166.3041, + "median": 665.1438, + "p95_nearest_rank": 720.5038, + "max": 721.1014 + }, + "shutdown_ms": { + "n": 3, + "min": 1.7943, + "median": 1.8177, + "p95_nearest_rank": 2.0195, + "max": 2.0195 + }, + "probe_window_coverage_batches": { + "timer": 3, + "network": 3 + }, + "probe_failures_in_window": { + "timer": 0, + "network": 0 + }, + "control_status": "NOTRUN", + "serialization_ms_per_batch_sum": { + "n": 3, + "min": 9.399, + "median": 9.5609, + "p95_nearest_rank": 9.5933, + "max": 9.5933 + }, + "mutex_wait_ms_per_batch_sum": { + "n": 3, + "min": 546.3954, + "median": 562.4312, + "p95_nearest_rank": 622.7948, + "max": 622.7948 + }, + "statement_ms_per_batch_sum": { + "n": 3, + "min": 622.7544, + "median": 623.4216, + "p95_nearest_rank": 661.0559, + "max": 661.0559 + }, + "timer_ms_in_window": { + "n": 20, + "min": 1.2373, + "median": 27.8632, + "p95_nearest_rank": 318.9988, + "max": 580.9868 + }, + "network_ms_in_window": { + "n": 16, + "min": 0.3608, + "median": 33.92865, + "p95_nearest_rank": 533.9077, + "max": 533.9077 + } + }, + { + "os": "Windows", + "profile": "release", + "workers": 0, + "transport": "HTTP", + "batches": 3, + "clients_successful": 96, + "persisted_rows": 96, + "successful_save_statements": 576, + "batch_ms": { + "n": 3, + "min": 575.2867, + "median": 600.5452, + "p95_nearest_rank": 606.5384, + "max": 606.5384 + }, + "client_ms": { + "n": 96, + "min": 570.0131, + "median": 598.1217, + "p95_nearest_rank": 605.6282, + "max": 606.1108 + }, + "shutdown_ms": { + "n": 3, + "min": 1.2916, + "median": 1.3122, + "p95_nearest_rank": 1.4611, + "max": 1.4611 + }, + "probe_window_coverage_batches": { + "timer": 3, + "network": 3 + }, + "probe_failures_in_window": { + "timer": 0, + "network": 0 + }, + "control_status": "PASS", + "serialization_ms_per_batch_sum": { + "n": 3, + "min": 0.9813, + "median": 1.0038, + "p95_nearest_rank": 1.0079, + "max": 1.0079 + }, + "mutex_wait_ms_per_batch_sum": { + "n": 3, + "min": 0.0086, + "median": 0.0092, + "p95_nearest_rank": 0.01, + "max": 0.01 + }, + "statement_ms_per_batch_sum": { + "n": 3, + "min": 558.6315, + "median": 586.7305, + "p95_nearest_rank": 593.9117, + "max": 593.9117 + }, + "timer_ms_in_window": { + "n": 3, + "min": 564.5989, + "median": 590.0228, + "p95_nearest_rank": 596.1102, + "max": 596.1102 + }, + "network_ms_in_window": { + "n": 5, + "min": 0.3321, + "median": 558.0494, + "p95_nearest_rank": 595.6781, + "max": 595.6781 + } + }, + { + "os": "Windows", + "profile": "release", + "workers": 0, + "transport": "TLS", + "batches": 3, + "clients_successful": 96, + "persisted_rows": 96, + "successful_save_statements": 576, + "batch_ms": { + "n": 3, + "min": 573.6908, + "median": 599.6354, + "p95_nearest_rank": 691.0549, + "max": 691.0549 + }, + "client_ms": { + "n": 96, + "min": 569.3921, + "median": 597.44925, + "p95_nearest_rank": 689.6464, + "max": 690.2845 + }, + "shutdown_ms": { + "n": 3, + "min": 0.5508, + "median": 0.617, + "p95_nearest_rank": 0.6503, + "max": 0.6503 + }, + "probe_window_coverage_batches": { + "timer": 3, + "network": 3 + }, + "probe_failures_in_window": { + "timer": 0, + "network": 0 + }, + "control_status": "PASS", + "serialization_ms_per_batch_sum": { + "n": 3, + "min": 0.9881, + "median": 1.0105, + "p95_nearest_rank": 1.0512, + "max": 1.0512 + }, + "mutex_wait_ms_per_batch_sum": { + "n": 3, + "min": 0.0088, + "median": 0.0093, + "p95_nearest_rank": 0.0106, + "max": 0.0106 + }, + "statement_ms_per_batch_sum": { + "n": 3, + "min": 537.4427, + "median": 559.2557, + "p95_nearest_rank": 610.4063, + "max": 610.4063 + }, + "timer_ms_in_window": { + "n": 7, + "min": 14.311, + "median": 60.9295, + "p95_nearest_rank": 568.5536, + "max": 568.5536 + }, + "network_ms_in_window": { + "n": 14, + "min": 0.6149, + "median": 7.252599999999999, + "p95_nearest_rank": 542.8624, + "max": 542.8624 + } + }, + { + "os": "Windows", + "profile": "release", + "workers": 2, + "transport": "HTTP", + "batches": 3, + "clients_successful": 96, + "persisted_rows": 96, + "successful_save_statements": 576, + "batch_ms": { + "n": 3, + "min": 561.4876, + "median": 563.1882, + "p95_nearest_rank": 573.3718, + "max": 573.3718 + }, + "client_ms": { + "n": 96, + "min": 266.0326, + "median": 546.29375, + "p95_nearest_rank": 569.1615, + "max": 570.9911 + }, + "shutdown_ms": { + "n": 3, + "min": 1.7843, + "median": 1.9612, + "p95_nearest_rank": 2.4155, + "max": 2.4155 + }, + "probe_window_coverage_batches": { + "timer": 3, + "network": 3 + }, + "probe_failures_in_window": { + "timer": 0, + "network": 0 + }, + "control_status": "NOTRUN", + "serialization_ms_per_batch_sum": { + "n": 3, + "min": 1.0454, + "median": 1.0962, + "p95_nearest_rank": 1.1191, + "max": 1.1191 + }, + "mutex_wait_ms_per_batch_sum": { + "n": 3, + "min": 539.2967, + "median": 545.8899, + "p95_nearest_rank": 560.3715, + "max": 560.3715 + }, + "statement_ms_per_batch_sum": { + "n": 3, + "min": 554.6892, + "median": 555.8004, + "p95_nearest_rank": 565.084, + "max": 565.084 + }, + "timer_ms_in_window": { + "n": 12, + "min": 0.3094, + "median": 36.7845, + "p95_nearest_rank": 559.001, + "max": 559.001 + }, + "network_ms_in_window": { + "n": 8, + "min": 0.3528, + "median": 251.16500000000002, + "p95_nearest_rank": 562.3282, + "max": 562.3282 + } + }, + { + "os": "Windows", + "profile": "release", + "workers": 2, + "transport": "TLS", + "batches": 3, + "clients_successful": 96, + "persisted_rows": 96, + "successful_save_statements": 576, + "batch_ms": { + "n": 3, + "min": 570.0818, + "median": 578.1471, + "p95_nearest_rank": 624.4967, + "max": 624.4967 + }, + "client_ms": { + "n": 96, + "min": 117.2919, + "median": 551.9529, + "p95_nearest_rank": 583.9921, + "max": 623.1036 + }, + "shutdown_ms": { + "n": 3, + "min": 0.584, + "median": 0.7019, + "p95_nearest_rank": 0.8294, + "max": 0.8294 + }, + "probe_window_coverage_batches": { + "timer": 3, + "network": 3 + }, + "probe_failures_in_window": { + "timer": 0, + "network": 0 + }, + "control_status": "NOTRUN", + "serialization_ms_per_batch_sum": { + "n": 3, + "min": 1.0232, + "median": 1.1055, + "p95_nearest_rank": 1.1573, + "max": 1.1573 + }, + "mutex_wait_ms_per_batch_sum": { + "n": 3, + "min": 525.5774, + "median": 534.2107, + "p95_nearest_rank": 546.393, + "max": 546.393 + }, + "statement_ms_per_batch_sum": { + "n": 3, + "min": 557.233, + "median": 561.5135, + "p95_nearest_rank": 563.7193, + "max": 563.7193 + }, + "timer_ms_in_window": { + "n": 18, + "min": 1.7836, + "median": 29.99975, + "p95_nearest_rank": 409.6201, + "max": 409.6201 + }, + "network_ms_in_window": { + "n": 15, + "min": 0.3766, + "median": 38.0534, + "p95_nearest_rank": 416.5828, + "max": 416.5828 + } + } + ], + "measurement_source_sha256": { + "Cargo.toml": "d373e3935d21d32ddd24db278ef082ea1ca50089ec4d6af362205dcfc43efd90", + "Cargo.lock": "fdb31f03309bc8e0a6bc80dfe026b4f50a0334b5c7bbc0e9008cc225cb69126f", + "rust-toolchain.toml": "f715f440167e20fd8ea9afa0498c3d1ab80174cfcb8cbc895f106a34d907a1e1", + "crates/scope-core/Cargo.toml": "5dc6d44211e1efbc49c3351a578d62c2b6b06cb1e0be7306f83f8cd57bfa373b", + "crates/scope-core/src/lib.rs": "70ed83d5acd0234d0adbc0c6150a01889f09b0cb1d9c8a3bc1ea59d4508eca30", + "crates/scope-core/src/diagnostics.rs": "c7588e52bb3f68418ff65f50986aa588f639e153c6ff9b6d6eca58f86e14603e", + "crates/scope-core/src/diagnostics/probes.rs": "4511cbbb7302b3d1ec28e2201edc24641a10fdb0377ce8532da9c13fd7e35273", + "crates/scope-core/src/diagnostics/workload.rs": "6296247345771d584e84905269571417b330a7e9a73784997aeb42f1a9f4137e", + "scripts/measure-archive.py": "c68aaf8870d2fcdb190b05e00d7a7aeb9dad5222368acb05b13c289e9b43a780", + ".github/workflows/archive-measurement.yml": "231def056063c7d20d17891330fc236561b764b72255109787ff4f724fdc410f", + ".github/workflows/har-compare-action.yml": "d62193de8b7fdfe54f3207fb1a7a198786e5f04e72aaae004da48857ff37b186" + }, + "artifact_receipts": [ + { + "os": "Linux", + "artifact_id": 13540878355, + "artifact_zip_sha256": "557ea7f7e2b2b395ec270f58f4b2611078a5bb3b75e67977a55e929b49ff2bcd" + }, + { + "os": "Windows", + "artifact_id": 13541022569, + "artifact_zip_sha256": "e0b2f3c65fd43e4fe179258d6a6dfd76a863c8c80059467f061e8ee3239c125d" + } + ] +} diff --git a/docs/benchmarks/archive-responsiveness-2026-11-06-windows.json b/docs/benchmarks/archive-responsiveness-2026-11-06-windows.json new file mode 100644 index 0000000..0eac234 --- /dev/null +++ b/docs/benchmarks/archive-responsiveness-2026-11-06-windows.json @@ -0,0 +1,39109 @@ +{ + "schema": 1, + "status": "PASS", + "metadata": { + "source_commit": "19aec4fc8ca63551c05a0380c157c5593f048efa", + "source_dirty": false, + "compiler": "rustc 1.99.1 (58cf8f9c3 2026-10-13)", + "os": "Windows", + "architecture": "AMD64", + "python": "3.12.10", + "hosted": { + "GITHUB_RUN_ID": "42293997874", + "GITHUB_RUN_ATTEMPT": "1", + "ImageOS": null, + "ImageVersion": null + }, + "resources": { + "logical_cpus": 4, + "affinity_cpus": null, + "cgroup_memory_max_bytes": null, + "cgroup_cpu_quota_us": null, + "cgroup_cpu_period_us": null, + "peak_child_rss": "NOTRUN", + "filesystem_type": "NOTRUN", + "io_quota": "NOTRUN" + }, + "build_jobs": 2, + "profiles": [ + "debug", + "release" + ], + "workers": [ + 0, + 2 + ], + "samples_per_transport": 3, + "build_hard_timeout_s": 600, + "child_hard_timeout_s": 420, + "overall_budget_s": 1800, + "optimization": { + "debug": "repository profile: opt-level=0,debug=1", + "release": "repository profile: opt-level=3,lto=thin,strip=true" + }, + "profile_limits": "environment flag/profile/wrapper overrides rejected; user Cargo configuration is not inspected; hosted jobs use clean checkout and toolchain", + "storage": "OS temporary directory; fresh file-backed SQLite archive per case; path omitted", + "unavailable_resource_fields": "null means NOTRUN or not exposed by this platform" + }, + "results": [ + { + "profile": "debug", + "workers": 0, + "status": "PASS", + "reason": null, + "report": { + "cases": [ + { + "batch_elapsed_ns": 753713000, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 751935800, + 751048300, + 750826900, + 750627600, + 750433000, + 750169100, + 749923700, + 749713800, + 749500200, + 749312700, + 749128100, + 748936900, + 748746000, + 748552800, + 748364400, + 748182800, + 747998500, + 747799500, + 747581800, + 747382900, + 747194000, + 747018300, + 746830700, + 746629500, + 746438400, + 746256800, + 746042900, + 746128700, + 745936000, + 745714600, + 745386600, + 745242500 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 8453500, + 731117300, + 430400, + 389700, + 544700 + ], + "failures": 0, + "in_window_samples": 2, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 8453500, + "end_ns": 19599300, + "in_window": true, + "scheduled_ns": null, + "start_ns": 11145800, + "success": true + }, + { + "elapsed_ns": 731117300, + "end_ns": 760880200, + "in_window": true, + "scheduled_ns": null, + "start_ns": 29762900, + "success": true + }, + { + "elapsed_ns": 430400, + "end_ns": 771771100, + "in_window": false, + "scheduled_ns": null, + "start_ns": 771340700, + "success": true + }, + { + "elapsed_ns": 389700, + "end_ns": 782297900, + "in_window": false, + "scheduled_ns": null, + "start_ns": 781908200, + "success": true + }, + { + "elapsed_ns": 544700, + "end_ns": 792954000, + "in_window": false, + "scheduled_ns": null, + "start_ns": 792409300, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 881600, + 731969900, + 1581200, + 2116200, + 2786100 + ], + "failures": 0, + "in_window_samples": 2, + "missed_periods": 73, + "samples": [ + { + "elapsed_ns": 881600, + "end_ns": 21056700, + "in_window": true, + "scheduled_ns": 20175100, + "start_ns": 21056700, + "success": true + }, + { + "elapsed_ns": 731969900, + "end_ns": 762145000, + "in_window": true, + "scheduled_ns": 30175100, + "start_ns": 762145000, + "success": true + }, + { + "elapsed_ns": 1581200, + "end_ns": 771756300, + "in_window": false, + "scheduled_ns": 770175100, + "start_ns": 771756300, + "success": true + }, + { + "elapsed_ns": 2116200, + "end_ns": 782291300, + "in_window": false, + "scheduled_ns": 780175100, + "start_ns": 782291300, + "success": true + }, + { + "elapsed_ns": 2786100, + "end_ns": 792961200, + "in_window": false, + "scheduled_ns": 790175100, + "start_ns": 792961200, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 763923700, + "window_start_ns": 10210700 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 0, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 500, + "serialization_ns": 44500, + "serialized_bytes": 612, + "statement_ns": 7112600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 34300, + "serialized_bytes": 612, + "statement_ns": 10868100, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 51100, + "serialized_bytes": 1038, + "statement_ns": 4459000, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 53700, + "serialized_bytes": 1077, + "statement_ns": 5240200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 55000, + "serialized_bytes": 1085, + "statement_ns": 4790900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 60800, + "serialized_bytes": 1301, + "statement_ns": 5224100, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 29300, + "serialized_bytes": 610, + "statement_ns": 4011800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31800, + "serialized_bytes": 610, + "statement_ns": 3089900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48500, + "serialized_bytes": 1034, + "statement_ns": 3717600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50400, + "serialized_bytes": 1073, + "statement_ns": 4538900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52600, + "serialized_bytes": 1081, + "statement_ns": 7767400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59200, + "serialized_bytes": 1297, + "statement_ns": 5590700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28900, + "serialized_bytes": 612, + "statement_ns": 6966800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31200, + "serialized_bytes": 612, + "statement_ns": 3217600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46900, + "serialized_bytes": 1038, + "statement_ns": 3375400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50900, + "serialized_bytes": 1077, + "statement_ns": 3260300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52000, + "serialized_bytes": 1085, + "statement_ns": 3614700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 59100, + "serialized_bytes": 1301, + "statement_ns": 9734800, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28800, + "serialized_bytes": 612, + "statement_ns": 4044900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 31400, + "serialized_bytes": 612, + "statement_ns": 5476200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48300, + "serialized_bytes": 1038, + "statement_ns": 5539600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 50800, + "serialized_bytes": 1077, + "statement_ns": 3298000, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 53400, + "serialized_bytes": 1085, + "statement_ns": 6042900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59600, + "serialized_bytes": 1301, + "statement_ns": 4515900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28900, + "serialized_bytes": 612, + "statement_ns": 3348300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 30400, + "serialized_bytes": 612, + "statement_ns": 3494200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46600, + "serialized_bytes": 1038, + "statement_ns": 3823200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50100, + "serialized_bytes": 1077, + "statement_ns": 4235700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52400, + "serialized_bytes": 1085, + "statement_ns": 4107600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59400, + "serialized_bytes": 1301, + "statement_ns": 4577500, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28600, + "serialized_bytes": 612, + "statement_ns": 6360100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 32200, + "serialized_bytes": 612, + "statement_ns": 3077500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48700, + "serialized_bytes": 1038, + "statement_ns": 3420500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50000, + "serialized_bytes": 1077, + "statement_ns": 3882800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53000, + "serialized_bytes": 1085, + "statement_ns": 3813000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59600, + "serialized_bytes": 1301, + "statement_ns": 4448200, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28000, + "serialized_bytes": 610, + "statement_ns": 3197500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31000, + "serialized_bytes": 610, + "statement_ns": 2936000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46900, + "serialized_bytes": 1034, + "statement_ns": 3044700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50700, + "serialized_bytes": 1073, + "statement_ns": 2694700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 52500, + "serialized_bytes": 1081, + "statement_ns": 3261200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58500, + "serialized_bytes": 1297, + "statement_ns": 3777700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 27900, + "serialized_bytes": 610, + "statement_ns": 7067600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31100, + "serialized_bytes": 610, + "statement_ns": 4200900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 49600, + "serialized_bytes": 1034, + "statement_ns": 2974000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53400, + "serialized_bytes": 1073, + "statement_ns": 3302700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52300, + "serialized_bytes": 1081, + "statement_ns": 4114500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58700, + "serialized_bytes": 1297, + "statement_ns": 3909600, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28900, + "serialized_bytes": 612, + "statement_ns": 4156300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30900, + "serialized_bytes": 612, + "statement_ns": 3256600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47900, + "serialized_bytes": 1038, + "statement_ns": 6119200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 51500, + "serialized_bytes": 1077, + "statement_ns": 3375700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52700, + "serialized_bytes": 1085, + "statement_ns": 4240900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 60000, + "serialized_bytes": 1301, + "statement_ns": 4802200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 27800, + "serialized_bytes": 612, + "statement_ns": 3613200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 32100, + "serialized_bytes": 612, + "statement_ns": 3633700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 48600, + "serialized_bytes": 1038, + "statement_ns": 4597800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50600, + "serialized_bytes": 1077, + "statement_ns": 2944400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52200, + "serialized_bytes": 1085, + "statement_ns": 2624000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59000, + "serialized_bytes": 1301, + "statement_ns": 3199700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28600, + "serialized_bytes": 610, + "statement_ns": 7045800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31500, + "serialized_bytes": 610, + "statement_ns": 3060200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48400, + "serialized_bytes": 1034, + "statement_ns": 3316500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50300, + "serialized_bytes": 1073, + "statement_ns": 3644400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53400, + "serialized_bytes": 1081, + "statement_ns": 3869500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58800, + "serialized_bytes": 1297, + "statement_ns": 3373600, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28200, + "serialized_bytes": 612, + "statement_ns": 4244000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30900, + "serialized_bytes": 612, + "statement_ns": 3560500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47900, + "serialized_bytes": 1038, + "statement_ns": 2626700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50200, + "serialized_bytes": 1077, + "statement_ns": 3555800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52500, + "serialized_bytes": 1085, + "statement_ns": 4614300, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 126000, + "serialized_bytes": 1301, + "statement_ns": 3308400, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 29800, + "serialized_bytes": 612, + "statement_ns": 3429400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 36000, + "serialized_bytes": 612, + "statement_ns": 2822700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49400, + "serialized_bytes": 1038, + "statement_ns": 2861600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50900, + "serialized_bytes": 1077, + "statement_ns": 2482100, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 100500, + "serialized_bytes": 1085, + "statement_ns": 2888100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 59100, + "serialized_bytes": 1301, + "statement_ns": 2957100, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28200, + "serialized_bytes": 610, + "statement_ns": 2848400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31100, + "serialized_bytes": 610, + "statement_ns": 3374800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46900, + "serialized_bytes": 1034, + "statement_ns": 4284900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50600, + "serialized_bytes": 1073, + "statement_ns": 2812900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52600, + "serialized_bytes": 1081, + "statement_ns": 4507600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59500, + "serialized_bytes": 1297, + "statement_ns": 3806200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 35700, + "serialized_bytes": 610, + "statement_ns": 3268600, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 47500, + "serialized_bytes": 610, + "statement_ns": 2773300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49700, + "serialized_bytes": 1034, + "statement_ns": 2610000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52100, + "serialized_bytes": 1073, + "statement_ns": 2626900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53900, + "serialized_bytes": 1081, + "statement_ns": 3232900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59600, + "serialized_bytes": 1297, + "statement_ns": 5287500, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 29600, + "serialized_bytes": 612, + "statement_ns": 3049300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 31100, + "serialized_bytes": 612, + "statement_ns": 2803500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47000, + "serialized_bytes": 1038, + "statement_ns": 2595700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50500, + "serialized_bytes": 1077, + "statement_ns": 2871900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51900, + "serialized_bytes": 1085, + "statement_ns": 3287700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58700, + "serialized_bytes": 1301, + "statement_ns": 3614300, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28200, + "serialized_bytes": 612, + "statement_ns": 4708100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30800, + "serialized_bytes": 612, + "statement_ns": 4386800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48200, + "serialized_bytes": 1038, + "statement_ns": 2760000, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 50500, + "serialized_bytes": 1077, + "statement_ns": 2558600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53100, + "serialized_bytes": 1085, + "statement_ns": 2876700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58700, + "serialized_bytes": 1301, + "statement_ns": 3241700, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28400, + "serialized_bytes": 612, + "statement_ns": 4420800, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 62700, + "serialized_bytes": 612, + "statement_ns": 3063600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47800, + "serialized_bytes": 1038, + "statement_ns": 3389100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 50100, + "serialized_bytes": 1077, + "statement_ns": 2458200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52800, + "serialized_bytes": 1085, + "statement_ns": 3624600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 57900, + "serialized_bytes": 1301, + "statement_ns": 6924400, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28600, + "serialized_bytes": 612, + "statement_ns": 2725400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30700, + "serialized_bytes": 612, + "statement_ns": 2683700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47100, + "serialized_bytes": 1038, + "statement_ns": 3965000, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 66100, + "serialized_bytes": 1077, + "statement_ns": 2933000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53900, + "serialized_bytes": 1085, + "statement_ns": 2573200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58900, + "serialized_bytes": 1301, + "statement_ns": 3957900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28200, + "serialized_bytes": 610, + "statement_ns": 3972000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31200, + "serialized_bytes": 610, + "statement_ns": 2652100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47200, + "serialized_bytes": 1034, + "statement_ns": 2602700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51400, + "serialized_bytes": 1073, + "statement_ns": 4671400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53000, + "serialized_bytes": 1081, + "statement_ns": 2986500, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 59400, + "serialized_bytes": 1297, + "statement_ns": 2572800, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28500, + "serialized_bytes": 610, + "statement_ns": 2997700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31800, + "serialized_bytes": 610, + "statement_ns": 3229800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 48700, + "serialized_bytes": 1034, + "statement_ns": 2598700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51000, + "serialized_bytes": 1073, + "statement_ns": 5308900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52400, + "serialized_bytes": 1081, + "statement_ns": 3104000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59600, + "serialized_bytes": 1297, + "statement_ns": 3978600, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 27800, + "serialized_bytes": 610, + "statement_ns": 4247900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 30900, + "serialized_bytes": 610, + "statement_ns": 3033900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47900, + "serialized_bytes": 1034, + "statement_ns": 2811300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50000, + "serialized_bytes": 1073, + "statement_ns": 2413500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52500, + "serialized_bytes": 1081, + "statement_ns": 5306800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 59200, + "serialized_bytes": 1297, + "statement_ns": 3354700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 29200, + "serialized_bytes": 612, + "statement_ns": 2950100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31900, + "serialized_bytes": 612, + "statement_ns": 5821200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 65000, + "serialized_bytes": 1038, + "statement_ns": 15344800, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 57400, + "serialized_bytes": 1077, + "statement_ns": 3434700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 55400, + "serialized_bytes": 1085, + "statement_ns": 3891000, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 60900, + "serialized_bytes": 1301, + "statement_ns": 2619600, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28500, + "serialized_bytes": 612, + "statement_ns": 2697400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31500, + "serialized_bytes": 612, + "statement_ns": 3410200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46900, + "serialized_bytes": 1038, + "statement_ns": 2318000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50800, + "serialized_bytes": 1077, + "statement_ns": 3256000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52900, + "serialized_bytes": 1085, + "statement_ns": 2530700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 61500, + "serialized_bytes": 1301, + "statement_ns": 3515100, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28700, + "serialized_bytes": 612, + "statement_ns": 2747100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31600, + "serialized_bytes": 612, + "statement_ns": 2953500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48100, + "serialized_bytes": 1038, + "statement_ns": 3027500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50000, + "serialized_bytes": 1077, + "statement_ns": 2534400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51700, + "serialized_bytes": 1085, + "statement_ns": 4446600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59000, + "serialized_bytes": 1301, + "statement_ns": 3091700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 29400, + "serialized_bytes": 612, + "statement_ns": 3096400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30800, + "serialized_bytes": 612, + "statement_ns": 2537700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48000, + "serialized_bytes": 1038, + "statement_ns": 2632100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50000, + "serialized_bytes": 1077, + "statement_ns": 3401700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52200, + "serialized_bytes": 1085, + "statement_ns": 2578400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58300, + "serialized_bytes": 1301, + "statement_ns": 3937100, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28600, + "serialized_bytes": 612, + "statement_ns": 2571600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31400, + "serialized_bytes": 612, + "statement_ns": 2581400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49200, + "serialized_bytes": 1038, + "statement_ns": 2884900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 65900, + "serialized_bytes": 1077, + "statement_ns": 2784500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52800, + "serialized_bytes": 1085, + "statement_ns": 2430800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58500, + "serialized_bytes": 1301, + "statement_ns": 2906700, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 44900, + "serialized_bytes": 612, + "statement_ns": 2680900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 46300, + "serialized_bytes": 612, + "statement_ns": 3501900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49200, + "serialized_bytes": 1038, + "statement_ns": 2929400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52900, + "serialized_bytes": 1077, + "statement_ns": 2812200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53800, + "serialized_bytes": 1085, + "statement_ns": 2772800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 60000, + "serialized_bytes": 1301, + "statement_ns": 2702700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 29400, + "serialized_bytes": 612, + "statement_ns": 4431600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48400, + "serialized_bytes": 612, + "statement_ns": 2387600, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 48800, + "serialized_bytes": 1038, + "statement_ns": 3051200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51600, + "serialized_bytes": 1077, + "statement_ns": 3187000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53200, + "serialized_bytes": 1085, + "statement_ns": 2405700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 60000, + "serialized_bytes": 1301, + "statement_ns": 2814700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28100, + "serialized_bytes": 610, + "statement_ns": 2788100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31200, + "serialized_bytes": 610, + "statement_ns": 2882700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47600, + "serialized_bytes": 1034, + "statement_ns": 2347200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50300, + "serialized_bytes": 1073, + "statement_ns": 2401300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52400, + "serialized_bytes": 1081, + "statement_ns": 7589800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59100, + "serialized_bytes": 1297, + "statement_ns": 2624000, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28300, + "serialized_bytes": 612, + "statement_ns": 7207900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31800, + "serialized_bytes": 612, + "statement_ns": 2446300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 48000, + "serialized_bytes": 1038, + "statement_ns": 2520300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51000, + "serialized_bytes": 1077, + "statement_ns": 2730100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52300, + "serialized_bytes": 1085, + "statement_ns": 2789800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59700, + "serialized_bytes": 1301, + "statement_ns": 3334600, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28200, + "serialized_bytes": 612, + "statement_ns": 3052900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 31100, + "serialized_bytes": 612, + "statement_ns": 2749300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49100, + "serialized_bytes": 1038, + "statement_ns": 4808100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51900, + "serialized_bytes": 1077, + "statement_ns": 2506900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52800, + "serialized_bytes": 1085, + "statement_ns": 3028500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 58300, + "serialized_bytes": 1301, + "statement_ns": 2884500, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 3655600, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=0", + "COMPILER=msvc-1944", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_W32", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "HTTP", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 673296400, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 671695400, + 671391700, + 671201300, + 671019600, + 670757700, + 670548800, + 670363300, + 670167100, + 669980100, + 669776900, + 669566500, + 669384100, + 669182600, + 668979600, + 668781200, + 668588600, + 668401000, + 668190000, + 668004400, + 667812600, + 667627600, + 667458300, + 667265400, + 667059800, + 666887300, + 666704300, + 666497000, + 666315700, + 666357900, + 666166800, + 665863000, + 665724700 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 59307200, + 592091700, + 408400, + 346900 + ], + "failures": 0, + "in_window_samples": 2, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 59307200, + "end_ns": 82718900, + "in_window": true, + "scheduled_ns": null, + "start_ns": 23411700, + "success": true + }, + { + "elapsed_ns": 592091700, + "end_ns": 685136300, + "in_window": true, + "scheduled_ns": null, + "start_ns": 93044600, + "success": true + }, + { + "elapsed_ns": 408400, + "end_ns": 695827300, + "in_window": false, + "scheduled_ns": null, + "start_ns": 695418900, + "success": true + }, + { + "elapsed_ns": 346900, + "end_ns": 706253300, + "in_window": false, + "scheduled_ns": null, + "start_ns": 705906400, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 660507600, + 2544100, + 3055400, + 3259900 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 66, + "samples": [ + { + "elapsed_ns": 660507600, + "end_ns": 683800500, + "in_window": true, + "scheduled_ns": 23292900, + "start_ns": 683800500, + "success": true + }, + { + "elapsed_ns": 2544100, + "end_ns": 695837000, + "in_window": false, + "scheduled_ns": 693292900, + "start_ns": 695837000, + "success": true + }, + { + "elapsed_ns": 3055400, + "end_ns": 706348300, + "in_window": false, + "scheduled_ns": 703292900, + "start_ns": 706348300, + "success": true + }, + { + "elapsed_ns": 3259900, + "end_ns": 716552800, + "in_window": false, + "scheduled_ns": 713292900, + "start_ns": 716552800, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 686663300, + "window_start_ns": 13366900 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 1, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 400, + "serialization_ns": 33100, + "serialized_bytes": 612, + "statement_ns": 3598200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 34200, + "serialized_bytes": 612, + "statement_ns": 2952200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50400, + "serialized_bytes": 1038, + "statement_ns": 2504400, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 52000, + "serialized_bytes": 1077, + "statement_ns": 2707400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52500, + "serialized_bytes": 1085, + "statement_ns": 2968400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59700, + "serialized_bytes": 1301, + "statement_ns": 2688800, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 27700, + "serialized_bytes": 610, + "statement_ns": 3126700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30800, + "serialized_bytes": 610, + "statement_ns": 3564500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47700, + "serialized_bytes": 1034, + "statement_ns": 3069300, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 49900, + "serialized_bytes": 1073, + "statement_ns": 4046700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 52400, + "serialized_bytes": 1081, + "statement_ns": 2918500, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 58500, + "serialized_bytes": 1297, + "statement_ns": 2924800, + "success": true + }, + { + "mutex_wait_ns": 600, + "serialization_ns": 52000, + "serialized_bytes": 612, + "statement_ns": 3015800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 32500, + "serialized_bytes": 612, + "statement_ns": 2933000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49300, + "serialized_bytes": 1038, + "statement_ns": 2460900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50500, + "serialized_bytes": 1077, + "statement_ns": 2854200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52400, + "serialized_bytes": 1085, + "statement_ns": 3296000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58300, + "serialized_bytes": 1301, + "statement_ns": 4716100, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28800, + "serialized_bytes": 612, + "statement_ns": 3342900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31100, + "serialized_bytes": 612, + "statement_ns": 2516300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47400, + "serialized_bytes": 1038, + "statement_ns": 2958800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50500, + "serialized_bytes": 1077, + "statement_ns": 2812000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52900, + "serialized_bytes": 1085, + "statement_ns": 3007700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59300, + "serialized_bytes": 1301, + "statement_ns": 2670700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28100, + "serialized_bytes": 612, + "statement_ns": 6087000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30800, + "serialized_bytes": 612, + "statement_ns": 4059800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47100, + "serialized_bytes": 1038, + "statement_ns": 2523100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 49900, + "serialized_bytes": 1077, + "statement_ns": 2460700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51800, + "serialized_bytes": 1085, + "statement_ns": 2714400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 57700, + "serialized_bytes": 1301, + "statement_ns": 6607300, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 27800, + "serialized_bytes": 612, + "statement_ns": 2525200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30700, + "serialized_bytes": 612, + "statement_ns": 2552700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47000, + "serialized_bytes": 1038, + "statement_ns": 2808000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49900, + "serialized_bytes": 1077, + "statement_ns": 2820100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51900, + "serialized_bytes": 1085, + "statement_ns": 2546300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58800, + "serialized_bytes": 1301, + "statement_ns": 2732500, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 27800, + "serialized_bytes": 612, + "statement_ns": 3219500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30600, + "serialized_bytes": 612, + "statement_ns": 2788700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 48000, + "serialized_bytes": 1038, + "statement_ns": 4554200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51700, + "serialized_bytes": 1077, + "statement_ns": 3025800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52400, + "serialized_bytes": 1085, + "statement_ns": 3123600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59500, + "serialized_bytes": 1301, + "statement_ns": 3268700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28500, + "serialized_bytes": 610, + "statement_ns": 3075300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31300, + "serialized_bytes": 610, + "statement_ns": 2844500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46600, + "serialized_bytes": 1034, + "statement_ns": 2730500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49600, + "serialized_bytes": 1073, + "statement_ns": 2703000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51700, + "serialized_bytes": 1081, + "statement_ns": 2859000, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 74300, + "serialized_bytes": 1297, + "statement_ns": 2707400, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28000, + "serialized_bytes": 610, + "statement_ns": 2967700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 30600, + "serialized_bytes": 610, + "statement_ns": 3529400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46800, + "serialized_bytes": 1034, + "statement_ns": 4201900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50300, + "serialized_bytes": 1073, + "statement_ns": 3257800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51900, + "serialized_bytes": 1081, + "statement_ns": 2586400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 58800, + "serialized_bytes": 1297, + "statement_ns": 2776600, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28400, + "serialized_bytes": 610, + "statement_ns": 3022900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 31000, + "serialized_bytes": 610, + "statement_ns": 2616300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46900, + "serialized_bytes": 1034, + "statement_ns": 2633400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50600, + "serialized_bytes": 1073, + "statement_ns": 3859200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51700, + "serialized_bytes": 1081, + "statement_ns": 2494800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58700, + "serialized_bytes": 1297, + "statement_ns": 3441800, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 27700, + "serialized_bytes": 610, + "statement_ns": 2856800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 30800, + "serialized_bytes": 610, + "statement_ns": 2566400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47700, + "serialized_bytes": 1034, + "statement_ns": 2654400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 50400, + "serialized_bytes": 1073, + "statement_ns": 2925800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53000, + "serialized_bytes": 1081, + "statement_ns": 2447300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58400, + "serialized_bytes": 1297, + "statement_ns": 3333800, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28000, + "serialized_bytes": 610, + "statement_ns": 3288700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31100, + "serialized_bytes": 610, + "statement_ns": 2646800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46700, + "serialized_bytes": 1034, + "statement_ns": 4570200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51100, + "serialized_bytes": 1073, + "statement_ns": 2337700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51800, + "serialized_bytes": 1081, + "statement_ns": 2688300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58500, + "serialized_bytes": 1297, + "statement_ns": 2660800, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 44400, + "serialized_bytes": 612, + "statement_ns": 2979800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30300, + "serialized_bytes": 612, + "statement_ns": 2287400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46800, + "serialized_bytes": 1038, + "statement_ns": 3414300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49900, + "serialized_bytes": 1077, + "statement_ns": 2442200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51800, + "serialized_bytes": 1085, + "statement_ns": 2720500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 58800, + "serialized_bytes": 1301, + "statement_ns": 4282100, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28000, + "serialized_bytes": 612, + "statement_ns": 3116000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31000, + "serialized_bytes": 612, + "statement_ns": 2666400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48000, + "serialized_bytes": 1038, + "statement_ns": 2700900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 48700, + "serialized_bytes": 1077, + "statement_ns": 2353400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51600, + "serialized_bytes": 1085, + "statement_ns": 3579300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 60300, + "serialized_bytes": 1301, + "statement_ns": 2926300, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 36000, + "serialized_bytes": 612, + "statement_ns": 3325300, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 39300, + "serialized_bytes": 612, + "statement_ns": 3271700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58200, + "serialized_bytes": 1038, + "statement_ns": 2739200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 50300, + "serialized_bytes": 1077, + "statement_ns": 2832000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52800, + "serialized_bytes": 1085, + "statement_ns": 2392400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 58300, + "serialized_bytes": 1301, + "statement_ns": 4230200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28100, + "serialized_bytes": 612, + "statement_ns": 2821400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31900, + "serialized_bytes": 612, + "statement_ns": 2519100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48400, + "serialized_bytes": 1038, + "statement_ns": 2331500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51400, + "serialized_bytes": 1077, + "statement_ns": 2973100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51900, + "serialized_bytes": 1085, + "statement_ns": 2681200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58200, + "serialized_bytes": 1301, + "statement_ns": 2501500, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28600, + "serialized_bytes": 612, + "statement_ns": 2948200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31000, + "serialized_bytes": 612, + "statement_ns": 2654800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47900, + "serialized_bytes": 1038, + "statement_ns": 3798200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50900, + "serialized_bytes": 1077, + "statement_ns": 2923200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52200, + "serialized_bytes": 1085, + "statement_ns": 2498600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58000, + "serialized_bytes": 1301, + "statement_ns": 3318200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28400, + "serialized_bytes": 612, + "statement_ns": 2941100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31500, + "serialized_bytes": 612, + "statement_ns": 2500100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47100, + "serialized_bytes": 1038, + "statement_ns": 2963200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49500, + "serialized_bytes": 1077, + "statement_ns": 2437400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52200, + "serialized_bytes": 1085, + "statement_ns": 3036700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58000, + "serialized_bytes": 1301, + "statement_ns": 2255000, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28500, + "serialized_bytes": 612, + "statement_ns": 3987700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 32800, + "serialized_bytes": 612, + "statement_ns": 2670500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48100, + "serialized_bytes": 1038, + "statement_ns": 2630100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51000, + "serialized_bytes": 1077, + "statement_ns": 2615300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53000, + "serialized_bytes": 1085, + "statement_ns": 2465300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58400, + "serialized_bytes": 1301, + "statement_ns": 2967500, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28600, + "serialized_bytes": 612, + "statement_ns": 3851500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 33400, + "serialized_bytes": 612, + "statement_ns": 3288700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49100, + "serialized_bytes": 1038, + "statement_ns": 3002400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 51000, + "serialized_bytes": 1077, + "statement_ns": 4026300, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 84400, + "serialized_bytes": 1085, + "statement_ns": 2652300, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 75900, + "serialized_bytes": 1301, + "statement_ns": 3294400, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 30100, + "serialized_bytes": 610, + "statement_ns": 5214200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 35400, + "serialized_bytes": 610, + "statement_ns": 3646400, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 63300, + "serialized_bytes": 1034, + "statement_ns": 3732200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 53600, + "serialized_bytes": 1073, + "statement_ns": 2961800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53000, + "serialized_bytes": 1081, + "statement_ns": 2530200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 73900, + "serialized_bytes": 1297, + "statement_ns": 3669100, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 36300, + "serialized_bytes": 612, + "statement_ns": 3485300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 38100, + "serialized_bytes": 612, + "statement_ns": 3928500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58700, + "serialized_bytes": 1038, + "statement_ns": 2786700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 61200, + "serialized_bytes": 1077, + "statement_ns": 2988700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 55900, + "serialized_bytes": 1085, + "statement_ns": 3910800, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 104000, + "serialized_bytes": 1301, + "statement_ns": 2799400, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 31600, + "serialized_bytes": 612, + "statement_ns": 15539600, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 77800, + "serialized_bytes": 612, + "statement_ns": 4755700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 59400, + "serialized_bytes": 1038, + "statement_ns": 5124600, + "success": true + }, + { + "mutex_wait_ns": 700, + "serialization_ns": 59500, + "serialized_bytes": 1077, + "statement_ns": 3669900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 61400, + "serialized_bytes": 1085, + "statement_ns": 3056600, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 65200, + "serialized_bytes": 1301, + "statement_ns": 4531700, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 31700, + "serialized_bytes": 610, + "statement_ns": 2969200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 37200, + "serialized_bytes": 610, + "statement_ns": 2702000, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 127400, + "serialized_bytes": 1034, + "statement_ns": 2445400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 54100, + "serialized_bytes": 1073, + "statement_ns": 2903500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 55300, + "serialized_bytes": 1081, + "statement_ns": 2687400, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 60400, + "serialized_bytes": 1297, + "statement_ns": 2423400, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28900, + "serialized_bytes": 610, + "statement_ns": 2538900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31700, + "serialized_bytes": 610, + "statement_ns": 5197700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48700, + "serialized_bytes": 1034, + "statement_ns": 3621100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51600, + "serialized_bytes": 1073, + "statement_ns": 2903700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53300, + "serialized_bytes": 1081, + "statement_ns": 5916500, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 60100, + "serialized_bytes": 1297, + "statement_ns": 3711900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28200, + "serialized_bytes": 612, + "statement_ns": 3218400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30700, + "serialized_bytes": 612, + "statement_ns": 4476500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48400, + "serialized_bytes": 1038, + "statement_ns": 3725400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 51300, + "serialized_bytes": 1077, + "statement_ns": 3749300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52600, + "serialized_bytes": 1085, + "statement_ns": 3072400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59600, + "serialized_bytes": 1301, + "statement_ns": 3921100, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 29700, + "serialized_bytes": 612, + "statement_ns": 6306200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 32800, + "serialized_bytes": 612, + "statement_ns": 3966300, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 48900, + "serialized_bytes": 1038, + "statement_ns": 2962100, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 51000, + "serialized_bytes": 1077, + "statement_ns": 3671000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52300, + "serialized_bytes": 1085, + "statement_ns": 2686500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59600, + "serialized_bytes": 1301, + "statement_ns": 3785600, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28500, + "serialized_bytes": 612, + "statement_ns": 3106100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31400, + "serialized_bytes": 612, + "statement_ns": 3934500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48500, + "serialized_bytes": 1038, + "statement_ns": 6653700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50600, + "serialized_bytes": 1077, + "statement_ns": 2524400, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 52200, + "serialized_bytes": 1085, + "statement_ns": 2710200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 59200, + "serialized_bytes": 1301, + "statement_ns": 2836900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28400, + "serialized_bytes": 610, + "statement_ns": 4953400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 31200, + "serialized_bytes": 610, + "statement_ns": 2670700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47000, + "serialized_bytes": 1034, + "statement_ns": 2868100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50700, + "serialized_bytes": 1073, + "statement_ns": 3947300, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 51200, + "serialized_bytes": 1081, + "statement_ns": 2743600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59800, + "serialized_bytes": 1297, + "statement_ns": 3226400, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28600, + "serialized_bytes": 612, + "statement_ns": 2874700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31000, + "serialized_bytes": 612, + "statement_ns": 2473700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48200, + "serialized_bytes": 1038, + "statement_ns": 3026900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 65500, + "serialized_bytes": 1077, + "statement_ns": 4344400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 56700, + "serialized_bytes": 1085, + "statement_ns": 3939000, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 59700, + "serialized_bytes": 1301, + "statement_ns": 2952100, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 27600, + "serialized_bytes": 612, + "statement_ns": 3434100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31700, + "serialized_bytes": 612, + "statement_ns": 2957300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48800, + "serialized_bytes": 1038, + "statement_ns": 4146100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50500, + "serialized_bytes": 1077, + "statement_ns": 2786100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51900, + "serialized_bytes": 1085, + "statement_ns": 3899200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 58900, + "serialized_bytes": 1301, + "statement_ns": 4744300, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28300, + "serialized_bytes": 612, + "statement_ns": 5638900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30900, + "serialized_bytes": 612, + "statement_ns": 3079500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48300, + "serialized_bytes": 1038, + "statement_ns": 3074000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51700, + "serialized_bytes": 1077, + "statement_ns": 3834700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52400, + "serialized_bytes": 1085, + "statement_ns": 4228500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59000, + "serialized_bytes": 1301, + "statement_ns": 3628900, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 2825300, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=0", + "COMPILER=msvc-1944", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_W32", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "HTTP", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 651912800, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 650283100, + 649922000, + 649719100, + 649540600, + 649368200, + 649182400, + 648980700, + 648800300, + 648630000, + 648405600, + 648186600, + 647989400, + 647785400, + 647593800, + 647417900, + 647243600, + 647079000, + 646904400, + 646733400, + 646536800, + 646368300, + 646204200, + 646036200, + 645853500, + 645666800, + 645490200, + 645283700, + 645106800, + 645171100, + 644997500, + 644704700, + 644486400 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 6025500, + 630647200, + 432900, + 389800 + ], + "failures": 0, + "in_window_samples": 2, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 6025500, + "end_ns": 19080200, + "in_window": true, + "scheduled_ns": null, + "start_ns": 13054700, + "success": true + }, + { + "elapsed_ns": 630647200, + "end_ns": 660279700, + "in_window": true, + "scheduled_ns": null, + "start_ns": 29632500, + "success": true + }, + { + "elapsed_ns": 432900, + "end_ns": 670915000, + "in_window": false, + "scheduled_ns": null, + "start_ns": 670482100, + "success": true + }, + { + "elapsed_ns": 389800, + "end_ns": 681450200, + "in_window": false, + "scheduled_ns": null, + "start_ns": 681060400, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 639140800, + 1808000, + 10728100, + 1166700 + ], + "failures": 0, + "in_window_samples": 2, + "missed_periods": 64, + "samples": [ + { + "elapsed_ns": 639140800, + "end_ns": 659857100, + "in_window": true, + "scheduled_ns": 20716300, + "start_ns": 659857100, + "success": true + }, + { + "elapsed_ns": 1808000, + "end_ns": 662524300, + "in_window": true, + "scheduled_ns": 660716300, + "start_ns": 662524300, + "success": true + }, + { + "elapsed_ns": 10728100, + "end_ns": 681444400, + "in_window": false, + "scheduled_ns": 670716300, + "start_ns": 681444400, + "success": true + }, + { + "elapsed_ns": 1166700, + "end_ns": 691883000, + "in_window": false, + "scheduled_ns": 690716300, + "start_ns": 691883000, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 662671600, + "window_start_ns": 10758800 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 2, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 600, + "serialization_ns": 35500, + "serialized_bytes": 612, + "statement_ns": 3774000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 34100, + "serialized_bytes": 612, + "statement_ns": 3218800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50300, + "serialized_bytes": 1038, + "statement_ns": 3224400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51300, + "serialized_bytes": 1077, + "statement_ns": 3138600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51700, + "serialized_bytes": 1085, + "statement_ns": 3618100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58800, + "serialized_bytes": 1301, + "statement_ns": 2766500, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28500, + "serialized_bytes": 612, + "statement_ns": 3096900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 33900, + "serialized_bytes": 612, + "statement_ns": 3032900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48200, + "serialized_bytes": 1038, + "statement_ns": 2643400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 50700, + "serialized_bytes": 1077, + "statement_ns": 2968600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51700, + "serialized_bytes": 1085, + "statement_ns": 3866000, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 71300, + "serialized_bytes": 1301, + "statement_ns": 3025200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28300, + "serialized_bytes": 612, + "statement_ns": 3506300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30800, + "serialized_bytes": 612, + "statement_ns": 3842300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46100, + "serialized_bytes": 1038, + "statement_ns": 3212100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 50600, + "serialized_bytes": 1077, + "statement_ns": 2919600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53100, + "serialized_bytes": 1085, + "statement_ns": 4716700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59400, + "serialized_bytes": 1301, + "statement_ns": 2779300, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28400, + "serialized_bytes": 612, + "statement_ns": 3151000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31400, + "serialized_bytes": 612, + "statement_ns": 2440100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47200, + "serialized_bytes": 1038, + "statement_ns": 4742200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51300, + "serialized_bytes": 1077, + "statement_ns": 3930400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52800, + "serialized_bytes": 1085, + "statement_ns": 2442100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59300, + "serialized_bytes": 1301, + "statement_ns": 2704200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28100, + "serialized_bytes": 612, + "statement_ns": 3616600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 31200, + "serialized_bytes": 612, + "statement_ns": 4394100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48000, + "serialized_bytes": 1038, + "statement_ns": 3055000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50700, + "serialized_bytes": 1077, + "statement_ns": 3141300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52000, + "serialized_bytes": 1085, + "statement_ns": 2802800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58500, + "serialized_bytes": 1301, + "statement_ns": 2918500, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 27400, + "serialized_bytes": 610, + "statement_ns": 2676100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30100, + "serialized_bytes": 610, + "statement_ns": 2425000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46700, + "serialized_bytes": 1034, + "statement_ns": 2342200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 50600, + "serialized_bytes": 1073, + "statement_ns": 2398400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52100, + "serialized_bytes": 1081, + "statement_ns": 2564300, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 105500, + "serialized_bytes": 1297, + "statement_ns": 3426400, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28000, + "serialized_bytes": 610, + "statement_ns": 4030100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31400, + "serialized_bytes": 610, + "statement_ns": 2702400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 45500, + "serialized_bytes": 1034, + "statement_ns": 2658900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49700, + "serialized_bytes": 1073, + "statement_ns": 2400200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52100, + "serialized_bytes": 1081, + "statement_ns": 2784600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58300, + "serialized_bytes": 1297, + "statement_ns": 2848400, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 27800, + "serialized_bytes": 610, + "statement_ns": 2811900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 30800, + "serialized_bytes": 610, + "statement_ns": 4888300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47700, + "serialized_bytes": 1034, + "statement_ns": 3053900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50500, + "serialized_bytes": 1073, + "statement_ns": 5182400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52200, + "serialized_bytes": 1081, + "statement_ns": 2609100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 56700, + "serialized_bytes": 1297, + "statement_ns": 2295200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 27300, + "serialized_bytes": 610, + "statement_ns": 2716600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31200, + "serialized_bytes": 610, + "statement_ns": 3036900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47500, + "serialized_bytes": 1034, + "statement_ns": 3085600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50700, + "serialized_bytes": 1073, + "statement_ns": 2584300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52300, + "serialized_bytes": 1081, + "statement_ns": 2796400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 57700, + "serialized_bytes": 1297, + "statement_ns": 3193700, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28300, + "serialized_bytes": 612, + "statement_ns": 4215500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31500, + "serialized_bytes": 612, + "statement_ns": 3066200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47900, + "serialized_bytes": 1038, + "statement_ns": 3655400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51100, + "serialized_bytes": 1077, + "statement_ns": 3030300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52100, + "serialized_bytes": 1085, + "statement_ns": 2467700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 80300, + "serialized_bytes": 1301, + "statement_ns": 2557100, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28500, + "serialized_bytes": 612, + "statement_ns": 3001700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 39500, + "serialized_bytes": 612, + "statement_ns": 2580600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47500, + "serialized_bytes": 1038, + "statement_ns": 3130000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49900, + "serialized_bytes": 1077, + "statement_ns": 3958800, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 53700, + "serialized_bytes": 1085, + "statement_ns": 3486400, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 104900, + "serialized_bytes": 1301, + "statement_ns": 4775300, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28900, + "serialized_bytes": 612, + "statement_ns": 4979000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 33500, + "serialized_bytes": 612, + "statement_ns": 2833400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48300, + "serialized_bytes": 1038, + "statement_ns": 2876100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51500, + "serialized_bytes": 1077, + "statement_ns": 2874200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53100, + "serialized_bytes": 1085, + "statement_ns": 2802800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 60000, + "serialized_bytes": 1301, + "statement_ns": 2668000, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 29100, + "serialized_bytes": 612, + "statement_ns": 3034200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31500, + "serialized_bytes": 612, + "statement_ns": 5723900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47400, + "serialized_bytes": 1038, + "statement_ns": 2402700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 51000, + "serialized_bytes": 1077, + "statement_ns": 8133600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51300, + "serialized_bytes": 1085, + "statement_ns": 3577900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 60200, + "serialized_bytes": 1301, + "statement_ns": 5138000, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28000, + "serialized_bytes": 610, + "statement_ns": 2836200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31000, + "serialized_bytes": 610, + "statement_ns": 3088100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48200, + "serialized_bytes": 1034, + "statement_ns": 3484400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48900, + "serialized_bytes": 1073, + "statement_ns": 3578700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51000, + "serialized_bytes": 1081, + "statement_ns": 3402500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58300, + "serialized_bytes": 1297, + "statement_ns": 3041500, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28200, + "serialized_bytes": 612, + "statement_ns": 3086100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31300, + "serialized_bytes": 612, + "statement_ns": 2870000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47600, + "serialized_bytes": 1038, + "statement_ns": 2505500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 49800, + "serialized_bytes": 1077, + "statement_ns": 2852000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51800, + "serialized_bytes": 1085, + "statement_ns": 3001500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58600, + "serialized_bytes": 1301, + "statement_ns": 4486000, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 29300, + "serialized_bytes": 612, + "statement_ns": 4082600, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 32300, + "serialized_bytes": 612, + "statement_ns": 3041800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48800, + "serialized_bytes": 1038, + "statement_ns": 2633900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48800, + "serialized_bytes": 1077, + "statement_ns": 2412300, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 65900, + "serialized_bytes": 1085, + "statement_ns": 2734600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 60700, + "serialized_bytes": 1301, + "statement_ns": 2470200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28600, + "serialized_bytes": 612, + "statement_ns": 2929200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31200, + "serialized_bytes": 612, + "statement_ns": 2472200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48400, + "serialized_bytes": 1038, + "statement_ns": 2412100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51200, + "serialized_bytes": 1077, + "statement_ns": 2625600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51300, + "serialized_bytes": 1085, + "statement_ns": 2493400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 59000, + "serialized_bytes": 1301, + "statement_ns": 3368200, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28300, + "serialized_bytes": 612, + "statement_ns": 5163300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31700, + "serialized_bytes": 612, + "statement_ns": 2550300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48000, + "serialized_bytes": 1038, + "statement_ns": 2512600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51000, + "serialized_bytes": 1077, + "statement_ns": 3642800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52400, + "serialized_bytes": 1085, + "statement_ns": 2554300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58600, + "serialized_bytes": 1301, + "statement_ns": 2862600, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 27800, + "serialized_bytes": 612, + "statement_ns": 3449900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30600, + "serialized_bytes": 612, + "statement_ns": 4120500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47300, + "serialized_bytes": 1038, + "statement_ns": 2732600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50200, + "serialized_bytes": 1077, + "statement_ns": 4172500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 55100, + "serialized_bytes": 1085, + "statement_ns": 2579700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59300, + "serialized_bytes": 1301, + "statement_ns": 2911900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28500, + "serialized_bytes": 612, + "statement_ns": 3114600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 35900, + "serialized_bytes": 612, + "statement_ns": 3532400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49900, + "serialized_bytes": 1038, + "statement_ns": 3165400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51900, + "serialized_bytes": 1077, + "statement_ns": 3904300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52400, + "serialized_bytes": 1085, + "statement_ns": 3067500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58800, + "serialized_bytes": 1301, + "statement_ns": 2818900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28200, + "serialized_bytes": 612, + "statement_ns": 3085700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 32800, + "serialized_bytes": 612, + "statement_ns": 2789700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48900, + "serialized_bytes": 1038, + "statement_ns": 2617800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 50800, + "serialized_bytes": 1077, + "statement_ns": 2639700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51700, + "serialized_bytes": 1085, + "statement_ns": 3974500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59700, + "serialized_bytes": 1301, + "statement_ns": 2854800, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28600, + "serialized_bytes": 610, + "statement_ns": 2859000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31200, + "serialized_bytes": 610, + "statement_ns": 2925600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48100, + "serialized_bytes": 1034, + "statement_ns": 3845900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50200, + "serialized_bytes": 1073, + "statement_ns": 3418000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51900, + "serialized_bytes": 1081, + "statement_ns": 3883300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59200, + "serialized_bytes": 1297, + "statement_ns": 2548200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28400, + "serialized_bytes": 612, + "statement_ns": 3201600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30700, + "serialized_bytes": 612, + "statement_ns": 4576700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46800, + "serialized_bytes": 1038, + "statement_ns": 2801400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50300, + "serialized_bytes": 1077, + "statement_ns": 2854900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52100, + "serialized_bytes": 1085, + "statement_ns": 2541400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58800, + "serialized_bytes": 1301, + "statement_ns": 3174600, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28700, + "serialized_bytes": 612, + "statement_ns": 2887600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 32000, + "serialized_bytes": 612, + "statement_ns": 4103900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49400, + "serialized_bytes": 1038, + "statement_ns": 2788400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52300, + "serialized_bytes": 1077, + "statement_ns": 3063300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 54600, + "serialized_bytes": 1085, + "statement_ns": 2883100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 61600, + "serialized_bytes": 1301, + "statement_ns": 2530900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28100, + "serialized_bytes": 610, + "statement_ns": 4545100, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 35900, + "serialized_bytes": 610, + "statement_ns": 2568800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50400, + "serialized_bytes": 1034, + "statement_ns": 2537300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52100, + "serialized_bytes": 1073, + "statement_ns": 2534700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53400, + "serialized_bytes": 1081, + "statement_ns": 3312800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 60500, + "serialized_bytes": 1297, + "statement_ns": 3491600, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28800, + "serialized_bytes": 610, + "statement_ns": 2993900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31100, + "serialized_bytes": 610, + "statement_ns": 2849700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47200, + "serialized_bytes": 1034, + "statement_ns": 2577500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 50900, + "serialized_bytes": 1073, + "statement_ns": 2811200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51500, + "serialized_bytes": 1081, + "statement_ns": 2427300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59300, + "serialized_bytes": 1297, + "statement_ns": 6072600, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28800, + "serialized_bytes": 610, + "statement_ns": 4295900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 32100, + "serialized_bytes": 610, + "statement_ns": 3573200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49100, + "serialized_bytes": 1034, + "statement_ns": 3067500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51000, + "serialized_bytes": 1073, + "statement_ns": 3126800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52600, + "serialized_bytes": 1081, + "statement_ns": 3001600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59900, + "serialized_bytes": 1297, + "statement_ns": 2844800, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28600, + "serialized_bytes": 612, + "statement_ns": 2948600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30800, + "serialized_bytes": 612, + "statement_ns": 2372600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48800, + "serialized_bytes": 1038, + "statement_ns": 2627900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51400, + "serialized_bytes": 1077, + "statement_ns": 2877800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52900, + "serialized_bytes": 1085, + "statement_ns": 2574100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59600, + "serialized_bytes": 1301, + "statement_ns": 3272700, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28800, + "serialized_bytes": 610, + "statement_ns": 3187400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 32500, + "serialized_bytes": 610, + "statement_ns": 2705200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47300, + "serialized_bytes": 1034, + "statement_ns": 4244600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53000, + "serialized_bytes": 1073, + "statement_ns": 2762000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52200, + "serialized_bytes": 1081, + "statement_ns": 4509900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 57300, + "serialized_bytes": 1297, + "statement_ns": 3119600, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28800, + "serialized_bytes": 612, + "statement_ns": 3004000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30600, + "serialized_bytes": 612, + "statement_ns": 2754300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 48000, + "serialized_bytes": 1038, + "statement_ns": 2472300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 50600, + "serialized_bytes": 1077, + "statement_ns": 2726300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51800, + "serialized_bytes": 1085, + "statement_ns": 2265700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58700, + "serialized_bytes": 1301, + "statement_ns": 2686200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 27900, + "serialized_bytes": 612, + "statement_ns": 5743700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31200, + "serialized_bytes": 612, + "statement_ns": 2845300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47900, + "serialized_bytes": 1038, + "statement_ns": 2992100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49500, + "serialized_bytes": 1077, + "statement_ns": 2685900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51500, + "serialized_bytes": 1085, + "statement_ns": 2491700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58100, + "serialized_bytes": 1301, + "statement_ns": 2977800, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28300, + "serialized_bytes": 612, + "statement_ns": 3198800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 31600, + "serialized_bytes": 612, + "statement_ns": 3104600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46900, + "serialized_bytes": 1038, + "statement_ns": 4551700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52800, + "serialized_bytes": 1077, + "statement_ns": 3023000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52400, + "serialized_bytes": 1085, + "statement_ns": 3921100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59700, + "serialized_bytes": 1301, + "statement_ns": 3221800, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 3321100, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=0", + "COMPILER=msvc-1944", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_W32", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "HTTP", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 851978900, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 847941600, + 843384600, + 843177100, + 844334200, + 844167400, + 843917000, + 849992500, + 849800800, + 849623200, + 849449700, + 849281800, + 849116900, + 848953100, + 848787200, + 848591700, + 848402700, + 848233200, + 848046500, + 847882800, + 847719200, + 847554900, + 847392400, + 847213500, + 847024600, + 846796000, + 846628800, + 846466900, + 846303800, + 846145300, + 846231900, + 846074900, + 845893900 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 1824000, + 5731500, + 73050400, + 24400700, + 19575300, + 666420100, + 396400, + 303300, + 331700 + ], + "failures": 0, + "in_window_samples": 6, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 1824000, + "end_ns": 14924700, + "in_window": true, + "scheduled_ns": null, + "start_ns": 13100700, + "success": true + }, + { + "elapsed_ns": 5731500, + "end_ns": 30789800, + "in_window": true, + "scheduled_ns": null, + "start_ns": 25058300, + "success": true + }, + { + "elapsed_ns": 73050400, + "end_ns": 114197800, + "in_window": true, + "scheduled_ns": null, + "start_ns": 41147400, + "success": true + }, + { + "elapsed_ns": 24400700, + "end_ns": 148682200, + "in_window": true, + "scheduled_ns": null, + "start_ns": 124281500, + "success": true + }, + { + "elapsed_ns": 19575300, + "end_ns": 178603100, + "in_window": true, + "scheduled_ns": null, + "start_ns": 159027800, + "success": true + }, + { + "elapsed_ns": 666420100, + "end_ns": 855222600, + "in_window": true, + "scheduled_ns": null, + "start_ns": 188802500, + "success": true + }, + { + "elapsed_ns": 396400, + "end_ns": 866087700, + "in_window": false, + "scheduled_ns": null, + "start_ns": 865691300, + "success": true + }, + { + "elapsed_ns": 303300, + "end_ns": 876771500, + "in_window": false, + "scheduled_ns": null, + "start_ns": 876468200, + "success": true + }, + { + "elapsed_ns": 331700, + "end_ns": 887204000, + "in_window": false, + "scheduled_ns": null, + "start_ns": 886872300, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 12795300, + 108100700, + 31223400, + 670227500, + 7706800, + 10560700 + ], + "failures": 0, + "in_window_samples": 4, + "missed_periods": 82, + "samples": [ + { + "elapsed_ns": 12795300, + "end_ns": 29425400, + "in_window": true, + "scheduled_ns": 16630100, + "start_ns": 29425400, + "success": true + }, + { + "elapsed_ns": 108100700, + "end_ns": 144730800, + "in_window": true, + "scheduled_ns": 36630100, + "start_ns": 144730800, + "success": true + }, + { + "elapsed_ns": 31223400, + "end_ns": 177853500, + "in_window": true, + "scheduled_ns": 146630100, + "start_ns": 177853500, + "success": true + }, + { + "elapsed_ns": 670227500, + "end_ns": 856857600, + "in_window": true, + "scheduled_ns": 186630100, + "start_ns": 856857600, + "success": true + }, + { + "elapsed_ns": 7706800, + "end_ns": 874336900, + "in_window": false, + "scheduled_ns": 866630100, + "start_ns": 874336900, + "success": true + }, + { + "elapsed_ns": 10560700, + "end_ns": 887190800, + "in_window": false, + "scheduled_ns": 876630100, + "start_ns": 887190800, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 858639700, + "window_start_ns": 6660800 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 0, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 700, + "serialization_ns": 36900, + "serialized_bytes": 613, + "statement_ns": 3645400, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 47400, + "serialized_bytes": 613, + "statement_ns": 2712300, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 92900, + "serialized_bytes": 1040, + "statement_ns": 4228300, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 66800, + "serialized_bytes": 1079, + "statement_ns": 2542700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 66400, + "serialized_bytes": 1087, + "statement_ns": 2462400, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 72500, + "serialized_bytes": 1303, + "statement_ns": 2436200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 29400, + "serialized_bytes": 611, + "statement_ns": 5353400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 33000, + "serialized_bytes": 611, + "statement_ns": 2313400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48500, + "serialized_bytes": 1036, + "statement_ns": 2537400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 55700, + "serialized_bytes": 1075, + "statement_ns": 4516600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 54200, + "serialized_bytes": 1083, + "statement_ns": 2526300, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 59100, + "serialized_bytes": 1299, + "statement_ns": 2791400, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28300, + "serialized_bytes": 611, + "statement_ns": 2944600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31900, + "serialized_bytes": 611, + "statement_ns": 3407600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48200, + "serialized_bytes": 1036, + "statement_ns": 2790700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50600, + "serialized_bytes": 1075, + "statement_ns": 4320100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53500, + "serialized_bytes": 1083, + "statement_ns": 2591400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 60200, + "serialized_bytes": 1299, + "statement_ns": 4251400, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 30100, + "serialized_bytes": 613, + "statement_ns": 2670100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 31400, + "serialized_bytes": 613, + "statement_ns": 2475400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49000, + "serialized_bytes": 1040, + "statement_ns": 2632100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 50400, + "serialized_bytes": 1079, + "statement_ns": 2888400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51400, + "serialized_bytes": 1087, + "statement_ns": 3081400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 57700, + "serialized_bytes": 1303, + "statement_ns": 2994800, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28000, + "serialized_bytes": 613, + "statement_ns": 2855100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 31600, + "serialized_bytes": 613, + "statement_ns": 2646100, + "success": true + }, + { + "mutex_wait_ns": 1100, + "serialization_ns": 120900, + "serialized_bytes": 1040, + "statement_ns": 2758500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52600, + "serialized_bytes": 1079, + "statement_ns": 2710800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 52800, + "serialized_bytes": 1087, + "statement_ns": 3651000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 60500, + "serialized_bytes": 1303, + "statement_ns": 3232600, + "success": true + }, + { + "mutex_wait_ns": 500, + "serialization_ns": 32200, + "serialized_bytes": 611, + "statement_ns": 3092200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 35700, + "serialized_bytes": 611, + "statement_ns": 2795900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 51000, + "serialized_bytes": 1036, + "statement_ns": 4309800, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 55500, + "serialized_bytes": 1075, + "statement_ns": 2468000, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 53900, + "serialized_bytes": 1083, + "statement_ns": 2869500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58200, + "serialized_bytes": 1299, + "statement_ns": 2479400, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28200, + "serialized_bytes": 611, + "statement_ns": 2958600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30800, + "serialized_bytes": 611, + "statement_ns": 3083200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47300, + "serialized_bytes": 1036, + "statement_ns": 3609000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50000, + "serialized_bytes": 1075, + "statement_ns": 2740700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51700, + "serialized_bytes": 1083, + "statement_ns": 2599500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58200, + "serialized_bytes": 1299, + "statement_ns": 3453200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 35800, + "serialized_bytes": 613, + "statement_ns": 4317600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 32200, + "serialized_bytes": 613, + "statement_ns": 2633700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48100, + "serialized_bytes": 1040, + "statement_ns": 2541600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50400, + "serialized_bytes": 1079, + "statement_ns": 3011900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52700, + "serialized_bytes": 1087, + "statement_ns": 2770200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59800, + "serialized_bytes": 1303, + "statement_ns": 3664000, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 29100, + "serialized_bytes": 613, + "statement_ns": 2864300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 32500, + "serialized_bytes": 613, + "statement_ns": 6913800, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 50000, + "serialized_bytes": 1040, + "statement_ns": 2716200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 54200, + "serialized_bytes": 1079, + "statement_ns": 2559200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 54000, + "serialized_bytes": 1087, + "statement_ns": 2470300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 61100, + "serialized_bytes": 1303, + "statement_ns": 3136700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 30700, + "serialized_bytes": 613, + "statement_ns": 2850400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 32700, + "serialized_bytes": 613, + "statement_ns": 2833200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49300, + "serialized_bytes": 1040, + "statement_ns": 3142900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51300, + "serialized_bytes": 1079, + "statement_ns": 2567300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53900, + "serialized_bytes": 1087, + "statement_ns": 3821600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59600, + "serialized_bytes": 1303, + "statement_ns": 4695600, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 29300, + "serialized_bytes": 613, + "statement_ns": 2909100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31700, + "serialized_bytes": 613, + "statement_ns": 2587200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48600, + "serialized_bytes": 1040, + "statement_ns": 2688200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50100, + "serialized_bytes": 1079, + "statement_ns": 2439700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51500, + "serialized_bytes": 1087, + "statement_ns": 3002300, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 60000, + "serialized_bytes": 1303, + "statement_ns": 2738000, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28000, + "serialized_bytes": 611, + "statement_ns": 3368900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 32000, + "serialized_bytes": 611, + "statement_ns": 2891800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48000, + "serialized_bytes": 1036, + "statement_ns": 2663000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49400, + "serialized_bytes": 1075, + "statement_ns": 2825600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51200, + "serialized_bytes": 1083, + "statement_ns": 2460800, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 59200, + "serialized_bytes": 1299, + "statement_ns": 2605800, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28500, + "serialized_bytes": 613, + "statement_ns": 3179900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31000, + "serialized_bytes": 613, + "statement_ns": 3220900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47400, + "serialized_bytes": 1040, + "statement_ns": 4148700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51000, + "serialized_bytes": 1079, + "statement_ns": 4748300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 65800, + "serialized_bytes": 1087, + "statement_ns": 3407600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 61500, + "serialized_bytes": 1303, + "statement_ns": 3326000, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28600, + "serialized_bytes": 613, + "statement_ns": 3165400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 32300, + "serialized_bytes": 613, + "statement_ns": 2593100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51500, + "serialized_bytes": 1040, + "statement_ns": 3046800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 49900, + "serialized_bytes": 1079, + "statement_ns": 2530600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52600, + "serialized_bytes": 1087, + "statement_ns": 3013700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 60000, + "serialized_bytes": 1303, + "statement_ns": 2821300, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 29100, + "serialized_bytes": 613, + "statement_ns": 3275100, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 31900, + "serialized_bytes": 613, + "statement_ns": 3106700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 50200, + "serialized_bytes": 1040, + "statement_ns": 2585100, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 53800, + "serialized_bytes": 1079, + "statement_ns": 2794800, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 54900, + "serialized_bytes": 1087, + "statement_ns": 2521800, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 62500, + "serialized_bytes": 1303, + "statement_ns": 4466200, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 29300, + "serialized_bytes": 611, + "statement_ns": 2843400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 32000, + "serialized_bytes": 611, + "statement_ns": 3875900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48500, + "serialized_bytes": 1036, + "statement_ns": 2700400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 93800, + "serialized_bytes": 1075, + "statement_ns": 2709200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50900, + "serialized_bytes": 1083, + "statement_ns": 2433400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 57800, + "serialized_bytes": 1299, + "statement_ns": 2503500, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28900, + "serialized_bytes": 613, + "statement_ns": 3710500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30800, + "serialized_bytes": 613, + "statement_ns": 2677800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 48500, + "serialized_bytes": 1040, + "statement_ns": 2333100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51700, + "serialized_bytes": 1079, + "statement_ns": 2834700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53200, + "serialized_bytes": 1087, + "statement_ns": 2820200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 58400, + "serialized_bytes": 1303, + "statement_ns": 3708400, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 29400, + "serialized_bytes": 613, + "statement_ns": 2997800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31300, + "serialized_bytes": 613, + "statement_ns": 2814800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48900, + "serialized_bytes": 1040, + "statement_ns": 2979900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50800, + "serialized_bytes": 1079, + "statement_ns": 2593600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 52500, + "serialized_bytes": 1087, + "statement_ns": 2290200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 59700, + "serialized_bytes": 1303, + "statement_ns": 2967300, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 29600, + "serialized_bytes": 613, + "statement_ns": 6623600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 36300, + "serialized_bytes": 613, + "statement_ns": 3263900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50500, + "serialized_bytes": 1040, + "statement_ns": 2618000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 52000, + "serialized_bytes": 1079, + "statement_ns": 2785700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 54200, + "serialized_bytes": 1087, + "statement_ns": 2755100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59100, + "serialized_bytes": 1303, + "statement_ns": 3023000, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28500, + "serialized_bytes": 611, + "statement_ns": 2625500, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 30900, + "serialized_bytes": 611, + "statement_ns": 3430400, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 48700, + "serialized_bytes": 1036, + "statement_ns": 2980700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51700, + "serialized_bytes": 1075, + "statement_ns": 3122900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 53300, + "serialized_bytes": 1083, + "statement_ns": 3042700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 59400, + "serialized_bytes": 1299, + "statement_ns": 2667200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 29300, + "serialized_bytes": 613, + "statement_ns": 3077400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31700, + "serialized_bytes": 613, + "statement_ns": 2757100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48600, + "serialized_bytes": 1040, + "statement_ns": 3562400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53100, + "serialized_bytes": 1079, + "statement_ns": 2876100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 55100, + "serialized_bytes": 1087, + "statement_ns": 2485800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 60300, + "serialized_bytes": 1303, + "statement_ns": 5677900, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 37700, + "serialized_bytes": 613, + "statement_ns": 3506600, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 35400, + "serialized_bytes": 613, + "statement_ns": 2652200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 52500, + "serialized_bytes": 1040, + "statement_ns": 2621400, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 52100, + "serialized_bytes": 1079, + "statement_ns": 2769100, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 54100, + "serialized_bytes": 1087, + "statement_ns": 2913200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 60100, + "serialized_bytes": 1303, + "statement_ns": 2628900, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 29100, + "serialized_bytes": 613, + "statement_ns": 3173600, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 31800, + "serialized_bytes": 613, + "statement_ns": 2594100, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 48200, + "serialized_bytes": 1040, + "statement_ns": 2426300, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 50700, + "serialized_bytes": 1079, + "statement_ns": 3583100, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 52600, + "serialized_bytes": 1087, + "statement_ns": 2421100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 57400, + "serialized_bytes": 1303, + "statement_ns": 2889400, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 27400, + "serialized_bytes": 613, + "statement_ns": 2837200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30900, + "serialized_bytes": 613, + "statement_ns": 2525800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48000, + "serialized_bytes": 1040, + "statement_ns": 3903100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50300, + "serialized_bytes": 1079, + "statement_ns": 2988900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52700, + "serialized_bytes": 1087, + "statement_ns": 2702500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 58700, + "serialized_bytes": 1303, + "statement_ns": 5380300, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28800, + "serialized_bytes": 613, + "statement_ns": 3252400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 32100, + "serialized_bytes": 613, + "statement_ns": 2707400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48900, + "serialized_bytes": 1040, + "statement_ns": 2674700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49700, + "serialized_bytes": 1079, + "statement_ns": 2599300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50900, + "serialized_bytes": 1087, + "statement_ns": 2394100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59200, + "serialized_bytes": 1303, + "statement_ns": 2584500, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 27800, + "serialized_bytes": 613, + "statement_ns": 3165900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31000, + "serialized_bytes": 613, + "statement_ns": 2375400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47400, + "serialized_bytes": 1040, + "statement_ns": 2553400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 50600, + "serialized_bytes": 1079, + "statement_ns": 2535700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52200, + "serialized_bytes": 1087, + "statement_ns": 2378200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58900, + "serialized_bytes": 1303, + "statement_ns": 2596800, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28200, + "serialized_bytes": 613, + "statement_ns": 3917500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 32100, + "serialized_bytes": 613, + "statement_ns": 2861400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48000, + "serialized_bytes": 1040, + "statement_ns": 2844200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50500, + "serialized_bytes": 1079, + "statement_ns": 2967100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52400, + "serialized_bytes": 1087, + "statement_ns": 3374600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59400, + "serialized_bytes": 1303, + "statement_ns": 4476800, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 35600, + "serialized_bytes": 613, + "statement_ns": 3068200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31800, + "serialized_bytes": 613, + "statement_ns": 2951000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48100, + "serialized_bytes": 1040, + "statement_ns": 2588400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49400, + "serialized_bytes": 1079, + "statement_ns": 3408400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 54800, + "serialized_bytes": 1087, + "statement_ns": 2597900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59800, + "serialized_bytes": 1303, + "statement_ns": 2802600, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28100, + "serialized_bytes": 611, + "statement_ns": 2710300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 31400, + "serialized_bytes": 611, + "statement_ns": 3091400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47800, + "serialized_bytes": 1036, + "statement_ns": 2276500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49800, + "serialized_bytes": 1075, + "statement_ns": 2498300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52500, + "serialized_bytes": 1083, + "statement_ns": 3125800, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 74100, + "serialized_bytes": 1299, + "statement_ns": 3555300, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 34300, + "serialized_bytes": 611, + "statement_ns": 3228000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 38200, + "serialized_bytes": 611, + "statement_ns": 3806000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51100, + "serialized_bytes": 1036, + "statement_ns": 3103500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 55600, + "serialized_bytes": 1075, + "statement_ns": 2603100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53000, + "serialized_bytes": 1083, + "statement_ns": 4814900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 91500, + "serialized_bytes": 1299, + "statement_ns": 2867900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28700, + "serialized_bytes": 611, + "statement_ns": 2954000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31800, + "serialized_bytes": 611, + "statement_ns": 2456100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47900, + "serialized_bytes": 1036, + "statement_ns": 2481500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51600, + "serialized_bytes": 1075, + "statement_ns": 3717600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 54000, + "serialized_bytes": 1083, + "statement_ns": 81247000, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 70400, + "serialized_bytes": 1299, + "statement_ns": 2988200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 31600, + "serialized_bytes": 613, + "statement_ns": 3636700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 33200, + "serialized_bytes": 613, + "statement_ns": 3454800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 48700, + "serialized_bytes": 1040, + "statement_ns": 2482800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50200, + "serialized_bytes": 1079, + "statement_ns": 3425300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 68000, + "serialized_bytes": 1087, + "statement_ns": 2469000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58900, + "serialized_bytes": 1303, + "statement_ns": 2498300, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 2108600, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=0", + "COMPILER=msvc-1944", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_W32", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "TLS", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 749694600, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 740887400, + 740718600, + 747347300, + 746995600, + 746789400, + 746603900, + 746426300, + 746240000, + 746046200, + 745868900, + 745695100, + 745497100, + 745280800, + 745073600, + 744864400, + 744673700, + 744496200, + 744318500, + 744139500, + 743958600, + 743785200, + 743611400, + 743485300, + 743362900, + 743200800, + 743005500, + 742809200, + 742927700, + 743416700, + 743241000, + 742461800, + 742274500 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 1963100, + 1541000, + 30897600, + 23224200, + 556016200, + 73440100, + 402000, + 360100 + ], + "failures": 0, + "in_window_samples": 6, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 1963100, + "end_ns": 31510300, + "in_window": true, + "scheduled_ns": null, + "start_ns": 29547200, + "success": true + }, + { + "elapsed_ns": 1541000, + "end_ns": 43213000, + "in_window": true, + "scheduled_ns": null, + "start_ns": 41672000, + "success": true + }, + { + "elapsed_ns": 30897600, + "end_ns": 84284400, + "in_window": true, + "scheduled_ns": null, + "start_ns": 53386800, + "success": true + }, + { + "elapsed_ns": 23224200, + "end_ns": 118006600, + "in_window": true, + "scheduled_ns": null, + "start_ns": 94782400, + "success": true + }, + { + "elapsed_ns": 556016200, + "end_ns": 684575500, + "in_window": true, + "scheduled_ns": null, + "start_ns": 128559300, + "success": true + }, + { + "elapsed_ns": 73440100, + "end_ns": 768589200, + "in_window": true, + "scheduled_ns": null, + "start_ns": 695149100, + "success": true + }, + { + "elapsed_ns": 402000, + "end_ns": 779504400, + "in_window": false, + "scheduled_ns": null, + "start_ns": 779102400, + "success": true + }, + { + "elapsed_ns": 360100, + "end_ns": 789990200, + "in_window": false, + "scheduled_ns": null, + "start_ns": 789630100, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 12768400, + 64765600, + 5940700, + 637275400, + 9422300, + 4161500, + 10146000 + ], + "failures": 0, + "in_window_samples": 4, + "missed_periods": 71, + "samples": [ + { + "elapsed_ns": 12768400, + "end_ns": 42290800, + "in_window": true, + "scheduled_ns": 29522400, + "start_ns": 42290800, + "success": true + }, + { + "elapsed_ns": 64765600, + "end_ns": 114288000, + "in_window": true, + "scheduled_ns": 49522400, + "start_ns": 114288000, + "success": true + }, + { + "elapsed_ns": 5940700, + "end_ns": 125463100, + "in_window": true, + "scheduled_ns": 119522400, + "start_ns": 125463100, + "success": true + }, + { + "elapsed_ns": 637275400, + "end_ns": 766797800, + "in_window": true, + "scheduled_ns": 129522400, + "start_ns": 766797800, + "success": true + }, + { + "elapsed_ns": 9422300, + "end_ns": 778944700, + "in_window": false, + "scheduled_ns": 769522400, + "start_ns": 778944700, + "success": true + }, + { + "elapsed_ns": 4161500, + "end_ns": 783683900, + "in_window": false, + "scheduled_ns": 779522400, + "start_ns": 783683900, + "success": true + }, + { + "elapsed_ns": 10146000, + "end_ns": 799668400, + "in_window": false, + "scheduled_ns": 789522400, + "start_ns": 799668400, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 769240800, + "window_start_ns": 19546200 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 1, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 600, + "serialization_ns": 34300, + "serialized_bytes": 613, + "statement_ns": 3508500, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 33400, + "serialized_bytes": 613, + "statement_ns": 3463700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48500, + "serialized_bytes": 1040, + "statement_ns": 2367000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51400, + "serialized_bytes": 1079, + "statement_ns": 3997100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52600, + "serialized_bytes": 1087, + "statement_ns": 2727600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58700, + "serialized_bytes": 1303, + "statement_ns": 4918700, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 27800, + "serialized_bytes": 611, + "statement_ns": 4311500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30900, + "serialized_bytes": 611, + "statement_ns": 5146000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47000, + "serialized_bytes": 1036, + "statement_ns": 2938700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50400, + "serialized_bytes": 1075, + "statement_ns": 2933000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52000, + "serialized_bytes": 1083, + "statement_ns": 2363700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 57900, + "serialized_bytes": 1299, + "statement_ns": 3654900, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 27700, + "serialized_bytes": 613, + "statement_ns": 2872600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30700, + "serialized_bytes": 613, + "statement_ns": 2252400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46900, + "serialized_bytes": 1040, + "statement_ns": 2606100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48800, + "serialized_bytes": 1079, + "statement_ns": 2438700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51200, + "serialized_bytes": 1087, + "statement_ns": 2302900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 57200, + "serialized_bytes": 1303, + "statement_ns": 2976400, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 27600, + "serialized_bytes": 611, + "statement_ns": 3047100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 32100, + "serialized_bytes": 611, + "statement_ns": 3424600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47800, + "serialized_bytes": 1036, + "statement_ns": 3109900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50200, + "serialized_bytes": 1075, + "statement_ns": 2628500, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 51900, + "serialized_bytes": 1083, + "statement_ns": 3072300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58100, + "serialized_bytes": 1299, + "statement_ns": 3409000, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28000, + "serialized_bytes": 611, + "statement_ns": 2890400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 29900, + "serialized_bytes": 611, + "statement_ns": 2750400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46800, + "serialized_bytes": 1036, + "statement_ns": 2876600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 49900, + "serialized_bytes": 1075, + "statement_ns": 2843100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51000, + "serialized_bytes": 1083, + "statement_ns": 2635000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 57700, + "serialized_bytes": 1299, + "statement_ns": 3475100, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 27600, + "serialized_bytes": 613, + "statement_ns": 2907800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30700, + "serialized_bytes": 613, + "statement_ns": 3012100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46800, + "serialized_bytes": 1040, + "statement_ns": 2698800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49900, + "serialized_bytes": 1079, + "statement_ns": 2736100, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 51800, + "serialized_bytes": 1087, + "statement_ns": 3317900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59100, + "serialized_bytes": 1303, + "statement_ns": 3489200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 27300, + "serialized_bytes": 613, + "statement_ns": 3215600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 31500, + "serialized_bytes": 613, + "statement_ns": 2983400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47700, + "serialized_bytes": 1040, + "statement_ns": 2697600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50800, + "serialized_bytes": 1079, + "statement_ns": 2476600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52400, + "serialized_bytes": 1087, + "statement_ns": 3279400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58600, + "serialized_bytes": 1303, + "statement_ns": 3299300, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28400, + "serialized_bytes": 613, + "statement_ns": 4580500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 34300, + "serialized_bytes": 613, + "statement_ns": 4704700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46900, + "serialized_bytes": 1040, + "statement_ns": 4376700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50900, + "serialized_bytes": 1079, + "statement_ns": 3568500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51300, + "serialized_bytes": 1087, + "statement_ns": 3559700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58400, + "serialized_bytes": 1303, + "statement_ns": 3277000, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28400, + "serialized_bytes": 613, + "statement_ns": 3596700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30800, + "serialized_bytes": 613, + "statement_ns": 2632000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47700, + "serialized_bytes": 1040, + "statement_ns": 2896200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49800, + "serialized_bytes": 1079, + "statement_ns": 2742400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51700, + "serialized_bytes": 1087, + "statement_ns": 4376200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58400, + "serialized_bytes": 1303, + "statement_ns": 3275400, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 27900, + "serialized_bytes": 613, + "statement_ns": 3883900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31100, + "serialized_bytes": 613, + "statement_ns": 2574900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48000, + "serialized_bytes": 1040, + "statement_ns": 5118000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49800, + "serialized_bytes": 1079, + "statement_ns": 2578600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52400, + "serialized_bytes": 1087, + "statement_ns": 3029800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58600, + "serialized_bytes": 1303, + "statement_ns": 2429700, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 27300, + "serialized_bytes": 613, + "statement_ns": 2951200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31200, + "serialized_bytes": 613, + "statement_ns": 2718900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 46900, + "serialized_bytes": 1040, + "statement_ns": 2758200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50400, + "serialized_bytes": 1079, + "statement_ns": 2804600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51400, + "serialized_bytes": 1087, + "statement_ns": 2391600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58200, + "serialized_bytes": 1303, + "statement_ns": 2905300, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 27900, + "serialized_bytes": 613, + "statement_ns": 2807700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31500, + "serialized_bytes": 613, + "statement_ns": 3060400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47100, + "serialized_bytes": 1040, + "statement_ns": 2754500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49600, + "serialized_bytes": 1079, + "statement_ns": 3021900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52000, + "serialized_bytes": 1087, + "statement_ns": 4767100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58100, + "serialized_bytes": 1303, + "statement_ns": 3031700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 27800, + "serialized_bytes": 613, + "statement_ns": 3937200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30500, + "serialized_bytes": 613, + "statement_ns": 2531800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46300, + "serialized_bytes": 1040, + "statement_ns": 4543800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50200, + "serialized_bytes": 1079, + "statement_ns": 2523500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51200, + "serialized_bytes": 1087, + "statement_ns": 3278000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59200, + "serialized_bytes": 1303, + "statement_ns": 3920000, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 27700, + "serialized_bytes": 613, + "statement_ns": 2716700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30500, + "serialized_bytes": 613, + "statement_ns": 2607000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46200, + "serialized_bytes": 1040, + "statement_ns": 3719600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49700, + "serialized_bytes": 1079, + "statement_ns": 2503400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51500, + "serialized_bytes": 1087, + "statement_ns": 3036600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58800, + "serialized_bytes": 1303, + "statement_ns": 3049200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28500, + "serialized_bytes": 611, + "statement_ns": 3097200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31800, + "serialized_bytes": 611, + "statement_ns": 2595600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49400, + "serialized_bytes": 1036, + "statement_ns": 2419700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50200, + "serialized_bytes": 1075, + "statement_ns": 3463100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51900, + "serialized_bytes": 1083, + "statement_ns": 3006400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 60000, + "serialized_bytes": 1299, + "statement_ns": 4311800, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28300, + "serialized_bytes": 611, + "statement_ns": 3497800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30800, + "serialized_bytes": 611, + "statement_ns": 3304500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48300, + "serialized_bytes": 1036, + "statement_ns": 3580300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50700, + "serialized_bytes": 1075, + "statement_ns": 2488600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52200, + "serialized_bytes": 1083, + "statement_ns": 2641500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59000, + "serialized_bytes": 1299, + "statement_ns": 4330200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28300, + "serialized_bytes": 613, + "statement_ns": 3302800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30600, + "serialized_bytes": 613, + "statement_ns": 2803400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47300, + "serialized_bytes": 1040, + "statement_ns": 2827200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 49700, + "serialized_bytes": 1079, + "statement_ns": 2653900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51300, + "serialized_bytes": 1087, + "statement_ns": 2860500, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 58400, + "serialized_bytes": 1303, + "statement_ns": 2523600, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 27900, + "serialized_bytes": 613, + "statement_ns": 2779500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 32100, + "serialized_bytes": 613, + "statement_ns": 2868700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47300, + "serialized_bytes": 1040, + "statement_ns": 2328300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49600, + "serialized_bytes": 1079, + "statement_ns": 2561800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52200, + "serialized_bytes": 1087, + "statement_ns": 3238200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58500, + "serialized_bytes": 1303, + "statement_ns": 2605400, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28100, + "serialized_bytes": 613, + "statement_ns": 2996900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30400, + "serialized_bytes": 613, + "statement_ns": 2426700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47600, + "serialized_bytes": 1040, + "statement_ns": 2442500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50100, + "serialized_bytes": 1079, + "statement_ns": 3044700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52100, + "serialized_bytes": 1087, + "statement_ns": 2925900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58600, + "serialized_bytes": 1303, + "statement_ns": 3283900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 29100, + "serialized_bytes": 613, + "statement_ns": 3762200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31000, + "serialized_bytes": 613, + "statement_ns": 2886800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46200, + "serialized_bytes": 1040, + "statement_ns": 2780800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49600, + "serialized_bytes": 1079, + "statement_ns": 6350500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51700, + "serialized_bytes": 1087, + "statement_ns": 3789900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58800, + "serialized_bytes": 1303, + "statement_ns": 2838100, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28300, + "serialized_bytes": 611, + "statement_ns": 3175700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30500, + "serialized_bytes": 611, + "statement_ns": 2690900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46500, + "serialized_bytes": 1036, + "statement_ns": 2863500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49800, + "serialized_bytes": 1075, + "statement_ns": 2380600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53000, + "serialized_bytes": 1083, + "statement_ns": 2448200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 57500, + "serialized_bytes": 1299, + "statement_ns": 3144700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28700, + "serialized_bytes": 611, + "statement_ns": 3334200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30300, + "serialized_bytes": 611, + "statement_ns": 3121200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46800, + "serialized_bytes": 1036, + "statement_ns": 2914500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49700, + "serialized_bytes": 1075, + "statement_ns": 2540600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51600, + "serialized_bytes": 1083, + "statement_ns": 2535200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 57200, + "serialized_bytes": 1299, + "statement_ns": 2665100, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28200, + "serialized_bytes": 611, + "statement_ns": 3157300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30400, + "serialized_bytes": 611, + "statement_ns": 2464000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46100, + "serialized_bytes": 1036, + "statement_ns": 2392100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49000, + "serialized_bytes": 1075, + "statement_ns": 2584700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 55700, + "serialized_bytes": 1083, + "statement_ns": 2771300, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 59000, + "serialized_bytes": 1299, + "statement_ns": 6302700, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28200, + "serialized_bytes": 611, + "statement_ns": 4931700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31700, + "serialized_bytes": 611, + "statement_ns": 2711600, + "success": true + }, + { + "mutex_wait_ns": 1200, + "serialization_ns": 105500, + "serialized_bytes": 1036, + "statement_ns": 2842300, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 52300, + "serialized_bytes": 1075, + "statement_ns": 2637700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 54100, + "serialized_bytes": 1083, + "statement_ns": 4121000, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 59500, + "serialized_bytes": 1299, + "statement_ns": 2561000, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 29200, + "serialized_bytes": 613, + "statement_ns": 7392000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 32800, + "serialized_bytes": 613, + "statement_ns": 3040300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 48900, + "serialized_bytes": 1040, + "statement_ns": 3115300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51700, + "serialized_bytes": 1079, + "statement_ns": 2485900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52100, + "serialized_bytes": 1087, + "statement_ns": 2625700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 60100, + "serialized_bytes": 1303, + "statement_ns": 5120500, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28100, + "serialized_bytes": 613, + "statement_ns": 4212600, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 52600, + "serialized_bytes": 613, + "statement_ns": 2474700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48100, + "serialized_bytes": 1040, + "statement_ns": 2877100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 51000, + "serialized_bytes": 1079, + "statement_ns": 3472100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52200, + "serialized_bytes": 1087, + "statement_ns": 2618200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59600, + "serialized_bytes": 1303, + "statement_ns": 2397200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28500, + "serialized_bytes": 613, + "statement_ns": 2821700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31000, + "serialized_bytes": 613, + "statement_ns": 6419200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47800, + "serialized_bytes": 1040, + "statement_ns": 2779700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52100, + "serialized_bytes": 1079, + "statement_ns": 2562000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52200, + "serialized_bytes": 1087, + "statement_ns": 3022000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59600, + "serialized_bytes": 1303, + "statement_ns": 4141000, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28100, + "serialized_bytes": 613, + "statement_ns": 2949700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 30200, + "serialized_bytes": 613, + "statement_ns": 2678800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48500, + "serialized_bytes": 1040, + "statement_ns": 2718200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51500, + "serialized_bytes": 1079, + "statement_ns": 2269800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53600, + "serialized_bytes": 1087, + "statement_ns": 3458300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58800, + "serialized_bytes": 1303, + "statement_ns": 5381100, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28700, + "serialized_bytes": 613, + "statement_ns": 2993800, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 98400, + "serialized_bytes": 613, + "statement_ns": 3217700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 47600, + "serialized_bytes": 1040, + "statement_ns": 3365600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50600, + "serialized_bytes": 1079, + "statement_ns": 2920500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51000, + "serialized_bytes": 1087, + "statement_ns": 2507900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 58900, + "serialized_bytes": 1303, + "statement_ns": 2917700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 27900, + "serialized_bytes": 613, + "statement_ns": 2838900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31100, + "serialized_bytes": 613, + "statement_ns": 2840700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46500, + "serialized_bytes": 1040, + "statement_ns": 2342300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50300, + "serialized_bytes": 1079, + "statement_ns": 2847900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51200, + "serialized_bytes": 1087, + "statement_ns": 2666800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58500, + "serialized_bytes": 1303, + "statement_ns": 2770200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28900, + "serialized_bytes": 613, + "statement_ns": 3400400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30800, + "serialized_bytes": 613, + "statement_ns": 3248600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47300, + "serialized_bytes": 1040, + "statement_ns": 2991500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51100, + "serialized_bytes": 1079, + "statement_ns": 3096600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52900, + "serialized_bytes": 1087, + "statement_ns": 3346500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59200, + "serialized_bytes": 1303, + "statement_ns": 5033400, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 29300, + "serialized_bytes": 611, + "statement_ns": 3553000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31100, + "serialized_bytes": 611, + "statement_ns": 3206300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46900, + "serialized_bytes": 1036, + "statement_ns": 3267200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50100, + "serialized_bytes": 1075, + "statement_ns": 4274300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52600, + "serialized_bytes": 1083, + "statement_ns": 4397200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58900, + "serialized_bytes": 1299, + "statement_ns": 3717300, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 2124200, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=0", + "COMPILER=msvc-1944", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_W32", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "TLS", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 725395600, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 715004800, + 714819100, + 723084500, + 722740000, + 722540500, + 722353900, + 722171400, + 721988100, + 721804000, + 721621800, + 721427100, + 721213400, + 720981600, + 720792600, + 720487700, + 720279600, + 720068400, + 719560900, + 719276800, + 719054800, + 718698000, + 718416300, + 718148800, + 717780200, + 717587400, + 717434900, + 717228300, + 717176800, + 717679200, + 717465400, + 716519400, + 716332100 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 2997600, + 1687500, + 30642400, + 24804900, + 536409200, + 67326500, + 391200, + 304800, + 643800 + ], + "failures": 0, + "in_window_samples": 6, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 2997600, + "end_ns": 29571200, + "in_window": true, + "scheduled_ns": null, + "start_ns": 26573600, + "success": true + }, + { + "elapsed_ns": 1687500, + "end_ns": 41345800, + "in_window": true, + "scheduled_ns": null, + "start_ns": 39658300, + "success": true + }, + { + "elapsed_ns": 30642400, + "end_ns": 82076500, + "in_window": true, + "scheduled_ns": null, + "start_ns": 51434100, + "success": true + }, + { + "elapsed_ns": 24804900, + "end_ns": 117037500, + "in_window": true, + "scheduled_ns": null, + "start_ns": 92232600, + "success": true + }, + { + "elapsed_ns": 536409200, + "end_ns": 663596400, + "in_window": true, + "scheduled_ns": null, + "start_ns": 127187200, + "success": true + }, + { + "elapsed_ns": 67326500, + "end_ns": 741031400, + "in_window": true, + "scheduled_ns": null, + "start_ns": 673704900, + "success": true + }, + { + "elapsed_ns": 391200, + "end_ns": 751588800, + "in_window": false, + "scheduled_ns": null, + "start_ns": 751197600, + "success": true + }, + { + "elapsed_ns": 304800, + "end_ns": 762001900, + "in_window": false, + "scheduled_ns": null, + "start_ns": 761697100, + "success": true + }, + { + "elapsed_ns": 643800, + "end_ns": 772737000, + "in_window": false, + "scheduled_ns": null, + "start_ns": 772093200, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 14178300, + 66999600, + 8429500, + 613022000, + 5338400, + 5784700, + 5938000 + ], + "failures": 0, + "in_window_samples": 4, + "missed_periods": 68, + "samples": [ + { + "elapsed_ns": 14178300, + "end_ns": 40437000, + "in_window": true, + "scheduled_ns": 26258700, + "start_ns": 40437000, + "success": true + }, + { + "elapsed_ns": 66999600, + "end_ns": 113258300, + "in_window": true, + "scheduled_ns": 46258700, + "start_ns": 113258300, + "success": true + }, + { + "elapsed_ns": 8429500, + "end_ns": 124688200, + "in_window": true, + "scheduled_ns": 116258700, + "start_ns": 124688200, + "success": true + }, + { + "elapsed_ns": 613022000, + "end_ns": 739280700, + "in_window": true, + "scheduled_ns": 126258700, + "start_ns": 739280700, + "success": true + }, + { + "elapsed_ns": 5338400, + "end_ns": 751597100, + "in_window": false, + "scheduled_ns": 746258700, + "start_ns": 751597100, + "success": true + }, + { + "elapsed_ns": 5784700, + "end_ns": 762043400, + "in_window": false, + "scheduled_ns": 756258700, + "start_ns": 762043400, + "success": true + }, + { + "elapsed_ns": 5938000, + "end_ns": 772196700, + "in_window": false, + "scheduled_ns": 766258700, + "start_ns": 772196700, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 741676700, + "window_start_ns": 16281100 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 2, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 600, + "serialization_ns": 36000, + "serialized_bytes": 613, + "statement_ns": 3991300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 32800, + "serialized_bytes": 613, + "statement_ns": 2715400, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 49100, + "serialized_bytes": 1040, + "statement_ns": 3805700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52200, + "serialized_bytes": 1079, + "statement_ns": 2725300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53200, + "serialized_bytes": 1087, + "statement_ns": 2518800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58800, + "serialized_bytes": 1303, + "statement_ns": 2577800, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 29200, + "serialized_bytes": 613, + "statement_ns": 3312100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 31200, + "serialized_bytes": 613, + "statement_ns": 2991500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47400, + "serialized_bytes": 1040, + "statement_ns": 2726900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50700, + "serialized_bytes": 1079, + "statement_ns": 2848700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51900, + "serialized_bytes": 1087, + "statement_ns": 2928800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 60000, + "serialized_bytes": 1303, + "statement_ns": 3530600, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28600, + "serialized_bytes": 611, + "statement_ns": 2767200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30400, + "serialized_bytes": 611, + "statement_ns": 2892500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47000, + "serialized_bytes": 1036, + "statement_ns": 2522800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49600, + "serialized_bytes": 1075, + "statement_ns": 2656700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51400, + "serialized_bytes": 1083, + "statement_ns": 2861300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58600, + "serialized_bytes": 1299, + "statement_ns": 3088500, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28600, + "serialized_bytes": 611, + "statement_ns": 3175400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31500, + "serialized_bytes": 611, + "statement_ns": 5788100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47800, + "serialized_bytes": 1036, + "statement_ns": 2716700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51900, + "serialized_bytes": 1075, + "statement_ns": 2659000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52500, + "serialized_bytes": 1083, + "statement_ns": 2982400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 62800, + "serialized_bytes": 1299, + "statement_ns": 2744200, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28600, + "serialized_bytes": 613, + "statement_ns": 2629100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30300, + "serialized_bytes": 613, + "statement_ns": 2584300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47700, + "serialized_bytes": 1040, + "statement_ns": 2427300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50300, + "serialized_bytes": 1079, + "statement_ns": 4740200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52200, + "serialized_bytes": 1087, + "statement_ns": 2900700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 58300, + "serialized_bytes": 1303, + "statement_ns": 2856900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28000, + "serialized_bytes": 613, + "statement_ns": 2871500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31000, + "serialized_bytes": 613, + "statement_ns": 2803300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46800, + "serialized_bytes": 1040, + "statement_ns": 2978100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49600, + "serialized_bytes": 1079, + "statement_ns": 2496200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51800, + "serialized_bytes": 1087, + "statement_ns": 2386400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58300, + "serialized_bytes": 1303, + "statement_ns": 2387000, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28100, + "serialized_bytes": 613, + "statement_ns": 2841200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31300, + "serialized_bytes": 613, + "statement_ns": 2613400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47400, + "serialized_bytes": 1040, + "statement_ns": 2525500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50100, + "serialized_bytes": 1079, + "statement_ns": 2842800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51700, + "serialized_bytes": 1087, + "statement_ns": 2980600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58400, + "serialized_bytes": 1303, + "statement_ns": 3483200, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28600, + "serialized_bytes": 611, + "statement_ns": 3295900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30300, + "serialized_bytes": 611, + "statement_ns": 3275600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 47300, + "serialized_bytes": 1036, + "statement_ns": 3256500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 50900, + "serialized_bytes": 1075, + "statement_ns": 3333800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52000, + "serialized_bytes": 1083, + "statement_ns": 2717900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 58900, + "serialized_bytes": 1299, + "statement_ns": 2946300, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 27600, + "serialized_bytes": 611, + "statement_ns": 2922200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31300, + "serialized_bytes": 611, + "statement_ns": 2540500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47000, + "serialized_bytes": 1036, + "statement_ns": 2751300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49100, + "serialized_bytes": 1075, + "statement_ns": 3041900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52500, + "serialized_bytes": 1083, + "statement_ns": 2778300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59100, + "serialized_bytes": 1299, + "statement_ns": 2998700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28400, + "serialized_bytes": 611, + "statement_ns": 3219700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30600, + "serialized_bytes": 611, + "statement_ns": 5712700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48000, + "serialized_bytes": 1036, + "statement_ns": 2765000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49700, + "serialized_bytes": 1075, + "statement_ns": 2878400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51900, + "serialized_bytes": 1083, + "statement_ns": 3414900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 57900, + "serialized_bytes": 1299, + "statement_ns": 2870500, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28600, + "serialized_bytes": 613, + "statement_ns": 5730600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 30500, + "serialized_bytes": 613, + "statement_ns": 2768400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47000, + "serialized_bytes": 1040, + "statement_ns": 3183700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49700, + "serialized_bytes": 1079, + "statement_ns": 2925900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 51800, + "serialized_bytes": 1087, + "statement_ns": 4068200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 58000, + "serialized_bytes": 1303, + "statement_ns": 3028300, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28600, + "serialized_bytes": 613, + "statement_ns": 3444500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31300, + "serialized_bytes": 613, + "statement_ns": 3567100, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 74400, + "serialized_bytes": 1040, + "statement_ns": 2704400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52300, + "serialized_bytes": 1079, + "statement_ns": 2893400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 52900, + "serialized_bytes": 1087, + "statement_ns": 2728900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58400, + "serialized_bytes": 1303, + "statement_ns": 4622900, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28900, + "serialized_bytes": 613, + "statement_ns": 3311200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 32500, + "serialized_bytes": 613, + "statement_ns": 2666900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 48500, + "serialized_bytes": 1040, + "statement_ns": 3128100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52600, + "serialized_bytes": 1079, + "statement_ns": 2894000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 54400, + "serialized_bytes": 1087, + "statement_ns": 3575300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 60400, + "serialized_bytes": 1303, + "statement_ns": 3332400, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 29000, + "serialized_bytes": 611, + "statement_ns": 3140300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 32100, + "serialized_bytes": 611, + "statement_ns": 2441500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47200, + "serialized_bytes": 1036, + "statement_ns": 3238200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 50700, + "serialized_bytes": 1075, + "statement_ns": 4209200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53000, + "serialized_bytes": 1083, + "statement_ns": 3199000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 60000, + "serialized_bytes": 1299, + "statement_ns": 2562500, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28800, + "serialized_bytes": 613, + "statement_ns": 3019600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30700, + "serialized_bytes": 613, + "statement_ns": 2938100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48100, + "serialized_bytes": 1040, + "statement_ns": 3803800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51200, + "serialized_bytes": 1079, + "statement_ns": 3697800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52300, + "serialized_bytes": 1087, + "statement_ns": 2842400, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 59800, + "serialized_bytes": 1303, + "statement_ns": 6289100, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 29500, + "serialized_bytes": 613, + "statement_ns": 3943300, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 32700, + "serialized_bytes": 613, + "statement_ns": 2634100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49100, + "serialized_bytes": 1040, + "statement_ns": 3081900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52000, + "serialized_bytes": 1079, + "statement_ns": 2818000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52800, + "serialized_bytes": 1087, + "statement_ns": 2567900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 60200, + "serialized_bytes": 1303, + "statement_ns": 2376900, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 29200, + "serialized_bytes": 613, + "statement_ns": 2945000, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 31500, + "serialized_bytes": 613, + "statement_ns": 2646300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50200, + "serialized_bytes": 1040, + "statement_ns": 4015300, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 52400, + "serialized_bytes": 1079, + "statement_ns": 4412700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 54400, + "serialized_bytes": 1087, + "statement_ns": 2802200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 60800, + "serialized_bytes": 1303, + "statement_ns": 2838200, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 30900, + "serialized_bytes": 611, + "statement_ns": 2861900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 32400, + "serialized_bytes": 611, + "statement_ns": 2454900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48300, + "serialized_bytes": 1036, + "statement_ns": 2890400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 50800, + "serialized_bytes": 1075, + "statement_ns": 3572100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51500, + "serialized_bytes": 1083, + "statement_ns": 3604600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 60000, + "serialized_bytes": 1299, + "statement_ns": 2845000, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28700, + "serialized_bytes": 611, + "statement_ns": 3031000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 30900, + "serialized_bytes": 611, + "statement_ns": 2717000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48200, + "serialized_bytes": 1036, + "statement_ns": 2685000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49200, + "serialized_bytes": 1075, + "statement_ns": 2275700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51800, + "serialized_bytes": 1083, + "statement_ns": 2494800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59600, + "serialized_bytes": 1299, + "statement_ns": 3174400, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 29400, + "serialized_bytes": 613, + "statement_ns": 3026800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31100, + "serialized_bytes": 613, + "statement_ns": 2364900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48200, + "serialized_bytes": 1040, + "statement_ns": 2423000, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 56900, + "serialized_bytes": 1079, + "statement_ns": 2530400, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 53100, + "serialized_bytes": 1087, + "statement_ns": 2911800, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 59600, + "serialized_bytes": 1303, + "statement_ns": 2778500, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 29100, + "serialized_bytes": 613, + "statement_ns": 2832500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31400, + "serialized_bytes": 613, + "statement_ns": 2767600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47700, + "serialized_bytes": 1040, + "statement_ns": 2712200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51300, + "serialized_bytes": 1079, + "statement_ns": 2784700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 78000, + "serialized_bytes": 1087, + "statement_ns": 3192700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 60100, + "serialized_bytes": 1303, + "statement_ns": 2689100, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28800, + "serialized_bytes": 613, + "statement_ns": 2960200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31500, + "serialized_bytes": 613, + "statement_ns": 2364800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47700, + "serialized_bytes": 1040, + "statement_ns": 2764900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50900, + "serialized_bytes": 1079, + "statement_ns": 2779000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52000, + "serialized_bytes": 1087, + "statement_ns": 2710900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 62800, + "serialized_bytes": 1303, + "statement_ns": 2584500, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 29900, + "serialized_bytes": 613, + "statement_ns": 3459500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 38600, + "serialized_bytes": 613, + "statement_ns": 2528300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47100, + "serialized_bytes": 1040, + "statement_ns": 3179000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50800, + "serialized_bytes": 1079, + "statement_ns": 2901300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52100, + "serialized_bytes": 1087, + "statement_ns": 2447000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59500, + "serialized_bytes": 1303, + "statement_ns": 3009800, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28200, + "serialized_bytes": 611, + "statement_ns": 2752800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30800, + "serialized_bytes": 611, + "statement_ns": 3314100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46900, + "serialized_bytes": 1036, + "statement_ns": 2777300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49800, + "serialized_bytes": 1075, + "statement_ns": 2900000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51300, + "serialized_bytes": 1083, + "statement_ns": 2483200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 57800, + "serialized_bytes": 1299, + "statement_ns": 2626800, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28000, + "serialized_bytes": 611, + "statement_ns": 2788700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 30500, + "serialized_bytes": 611, + "statement_ns": 3302700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47200, + "serialized_bytes": 1036, + "statement_ns": 3000800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49900, + "serialized_bytes": 1075, + "statement_ns": 2500100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51600, + "serialized_bytes": 1083, + "statement_ns": 3446200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58800, + "serialized_bytes": 1299, + "statement_ns": 2694300, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28100, + "serialized_bytes": 613, + "statement_ns": 3082000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30900, + "serialized_bytes": 613, + "statement_ns": 2481500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46900, + "serialized_bytes": 1040, + "statement_ns": 2947700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49900, + "serialized_bytes": 1079, + "statement_ns": 2777800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51500, + "serialized_bytes": 1087, + "statement_ns": 2622100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59100, + "serialized_bytes": 1303, + "statement_ns": 3770300, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28600, + "serialized_bytes": 613, + "statement_ns": 2957700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 31200, + "serialized_bytes": 613, + "statement_ns": 5014100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47600, + "serialized_bytes": 1040, + "statement_ns": 2497400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50500, + "serialized_bytes": 1079, + "statement_ns": 3720800, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 51500, + "serialized_bytes": 1087, + "statement_ns": 2413700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 58900, + "serialized_bytes": 1303, + "statement_ns": 3973600, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28300, + "serialized_bytes": 613, + "statement_ns": 2551700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30600, + "serialized_bytes": 613, + "statement_ns": 2809100, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 70900, + "serialized_bytes": 1040, + "statement_ns": 2797300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 63100, + "serialized_bytes": 1079, + "statement_ns": 3010800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53400, + "serialized_bytes": 1087, + "statement_ns": 4341400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 60100, + "serialized_bytes": 1303, + "statement_ns": 3567400, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28800, + "serialized_bytes": 613, + "statement_ns": 3043100, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 31900, + "serialized_bytes": 613, + "statement_ns": 2803900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 48900, + "serialized_bytes": 1040, + "statement_ns": 3372600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51200, + "serialized_bytes": 1079, + "statement_ns": 4145600, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 51900, + "serialized_bytes": 1087, + "statement_ns": 2693700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 59200, + "serialized_bytes": 1303, + "statement_ns": 3193700, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 28800, + "serialized_bytes": 613, + "statement_ns": 2649700, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 30800, + "serialized_bytes": 613, + "statement_ns": 2664600, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 47200, + "serialized_bytes": 1040, + "statement_ns": 2910400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51900, + "serialized_bytes": 1079, + "statement_ns": 2983100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 53600, + "serialized_bytes": 1087, + "statement_ns": 2867000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59300, + "serialized_bytes": 1303, + "statement_ns": 2687900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28200, + "serialized_bytes": 613, + "statement_ns": 3919300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30200, + "serialized_bytes": 613, + "statement_ns": 2908500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 47300, + "serialized_bytes": 1040, + "statement_ns": 2337700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 50000, + "serialized_bytes": 1079, + "statement_ns": 2823700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51300, + "serialized_bytes": 1087, + "statement_ns": 2790700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59600, + "serialized_bytes": 1303, + "statement_ns": 2734300, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 28800, + "serialized_bytes": 613, + "statement_ns": 3423800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 30800, + "serialized_bytes": 613, + "statement_ns": 2801400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 46800, + "serialized_bytes": 1040, + "statement_ns": 3279400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49700, + "serialized_bytes": 1079, + "statement_ns": 2525000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52000, + "serialized_bytes": 1087, + "statement_ns": 2439200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59300, + "serialized_bytes": 1303, + "statement_ns": 3147400, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 1763000, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=0", + "COMPILER=msvc-1944", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_W32", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "TLS", + "wall_budget_exceeded": false + } + ], + "not_run": { + "disk_flush_count": "not observed", + "gui_android": "outside harness", + "production_performance": "synthetic test-only harness", + "queue_wait": "no writer queue exists", + "sqlite_busy_wait_separate": "included in statement elapsed" + }, + "profile": "debug", + "runtime": "current_thread", + "schema": 1, + "status": "PASS", + "timer_network_positive_control": { + "detector_threshold_ms": 100, + "injected_block_ms": 300, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 290694800, + 392800, + 476000 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 290694800, + "end_ns": 318671400, + "in_window": true, + "scheduled_ns": null, + "start_ns": 27976600, + "success": true + }, + { + "elapsed_ns": 392800, + "end_ns": 329340300, + "in_window": false, + "scheduled_ns": null, + "start_ns": 328947500, + "success": true + }, + { + "elapsed_ns": 476000, + "end_ns": 340180500, + "in_window": false, + "scheduled_ns": null, + "start_ns": 339704500, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 290684200, + 1440700, + 2314000 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 29, + "samples": [ + { + "elapsed_ns": 290684200, + "end_ns": 318591900, + "in_window": true, + "scheduled_ns": 27907700, + "start_ns": 318591900, + "success": true + }, + { + "elapsed_ns": 1440700, + "end_ns": 329348400, + "in_window": false, + "scheduled_ns": 327907700, + "start_ns": 329348400, + "success": true + }, + { + "elapsed_ns": 2314000, + "end_ns": 340221700, + "in_window": false, + "scheduled_ns": 337907700, + "start_ns": 340221700, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 318300800, + "window_start_ns": 17931700 + }, + "status": "PASS" + }, + "workers": 0 + }, + "cleanup_uncertain": false + }, + { + "profile": "debug", + "workers": 2, + "status": "PASS", + "reason": null, + "report": { + "cases": [ + { + "batch_elapsed_ns": 643082400, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 637856500, + 636614000, + 636732500, + 639525800, + 636694300, + 639709900, + 636896600, + 639101700, + 636819700, + 639270700, + 637019900, + 638884500, + 637010700, + 639356700, + 637210300, + 639338400, + 637209100, + 637093000, + 637418200, + 639446900, + 639636100, + 636736800, + 637812400, + 639828800, + 637758800, + 639828900, + 637891100, + 639962200, + 637941500, + 639975500, + 638033200, + 640335200 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 661100, + 629278700, + 353300, + 407700, + 399000 + ], + "failures": 0, + "in_window_samples": 2, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 661100, + "end_ns": 11717600, + "in_window": true, + "scheduled_ns": null, + "start_ns": 11056500, + "success": true + }, + { + "elapsed_ns": 629278700, + "end_ns": 651146600, + "in_window": true, + "scheduled_ns": null, + "start_ns": 21867900, + "success": true + }, + { + "elapsed_ns": 353300, + "end_ns": 661914600, + "in_window": false, + "scheduled_ns": null, + "start_ns": 661561300, + "success": true + }, + { + "elapsed_ns": 407700, + "end_ns": 672432300, + "in_window": false, + "scheduled_ns": null, + "start_ns": 672024600, + "success": true + }, + { + "elapsed_ns": 399000, + "end_ns": 682961500, + "in_window": false, + "scheduled_ns": null, + "start_ns": 682562500, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 407396900, + 221896500, + 10661600, + 1056200, + 15847600 + ], + "failures": 0, + "in_window_samples": 2, + "missed_periods": 64, + "samples": [ + { + "elapsed_ns": 407396900, + "end_ns": 428991100, + "in_window": true, + "scheduled_ns": 21594200, + "start_ns": 428991100, + "success": true + }, + { + "elapsed_ns": 221896500, + "end_ns": 653490700, + "in_window": true, + "scheduled_ns": 431594200, + "start_ns": 653490700, + "success": true + }, + { + "elapsed_ns": 10661600, + "end_ns": 672255800, + "in_window": false, + "scheduled_ns": 661594200, + "start_ns": 672255800, + "success": true + }, + { + "elapsed_ns": 1056200, + "end_ns": 682650400, + "in_window": false, + "scheduled_ns": 681594200, + "start_ns": 682650400, + "success": true + }, + { + "elapsed_ns": 15847600, + "end_ns": 707441800, + "in_window": false, + "scheduled_ns": 691594200, + "start_ns": 707441800, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 654708200, + "window_start_ns": 11625800 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 0, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 700, + "serialization_ns": 39100, + "serialized_bytes": 612, + "statement_ns": 4129200, + "success": true + }, + { + "mutex_wait_ns": 1936000, + "serialization_ns": 33800, + "serialized_bytes": 610, + "statement_ns": 5372000, + "success": true + }, + { + "mutex_wait_ns": 5359500, + "serialization_ns": 33600, + "serialized_bytes": 612, + "statement_ns": 2649200, + "success": true + }, + { + "mutex_wait_ns": 2637000, + "serialization_ns": 38400, + "serialized_bytes": 610, + "statement_ns": 2444500, + "success": true + }, + { + "mutex_wait_ns": 2378800, + "serialization_ns": 51900, + "serialized_bytes": 1038, + "statement_ns": 2416100, + "success": true + }, + { + "mutex_wait_ns": 2352100, + "serialization_ns": 51200, + "serialized_bytes": 1034, + "statement_ns": 2655300, + "success": true + }, + { + "mutex_wait_ns": 2558400, + "serialization_ns": 55500, + "serialized_bytes": 1077, + "statement_ns": 2625300, + "success": true + }, + { + "mutex_wait_ns": 2551300, + "serialization_ns": 53800, + "serialized_bytes": 1073, + "statement_ns": 2589700, + "success": true + }, + { + "mutex_wait_ns": 2533600, + "serialization_ns": 56200, + "serialized_bytes": 1085, + "statement_ns": 2766000, + "success": true + }, + { + "mutex_wait_ns": 2721000, + "serialization_ns": 55000, + "serialized_bytes": 1081, + "statement_ns": 2628500, + "success": true + }, + { + "mutex_wait_ns": 2550800, + "serialization_ns": 61000, + "serialized_bytes": 1301, + "statement_ns": 2657800, + "success": true + }, + { + "mutex_wait_ns": 2592900, + "serialization_ns": 60900, + "serialized_bytes": 1297, + "statement_ns": 2921100, + "success": true + }, + { + "mutex_wait_ns": 2569400, + "serialization_ns": 28900, + "serialized_bytes": 612, + "statement_ns": 2858500, + "success": true + }, + { + "mutex_wait_ns": 2617200, + "serialization_ns": 28300, + "serialized_bytes": 612, + "statement_ns": 2889500, + "success": true + }, + { + "mutex_wait_ns": 2882500, + "serialization_ns": 32000, + "serialized_bytes": 612, + "statement_ns": 2643200, + "success": true + }, + { + "mutex_wait_ns": 2634700, + "serialization_ns": 32300, + "serialized_bytes": 612, + "statement_ns": 2955400, + "success": true + }, + { + "mutex_wait_ns": 2908700, + "serialization_ns": 49600, + "serialized_bytes": 1038, + "statement_ns": 2485800, + "success": true + }, + { + "mutex_wait_ns": 2441600, + "serialization_ns": 51100, + "serialized_bytes": 1038, + "statement_ns": 2942100, + "success": true + }, + { + "mutex_wait_ns": 2851000, + "serialization_ns": 68000, + "serialized_bytes": 1077, + "statement_ns": 2413600, + "success": true + }, + { + "mutex_wait_ns": 2345400, + "serialization_ns": 52800, + "serialized_bytes": 1077, + "statement_ns": 2687200, + "success": true + }, + { + "mutex_wait_ns": 2638700, + "serialization_ns": 53300, + "serialized_bytes": 1085, + "statement_ns": 2717200, + "success": true + }, + { + "mutex_wait_ns": 2672300, + "serialization_ns": 55000, + "serialized_bytes": 1085, + "statement_ns": 2434300, + "success": true + }, + { + "mutex_wait_ns": 2361200, + "serialization_ns": 63400, + "serialized_bytes": 1301, + "statement_ns": 3777900, + "success": true + }, + { + "mutex_wait_ns": 3718300, + "serialization_ns": 59800, + "serialized_bytes": 1301, + "statement_ns": 4604600, + "success": true + }, + { + "mutex_wait_ns": 4272200, + "serialization_ns": 28800, + "serialized_bytes": 612, + "statement_ns": 2704900, + "success": true + }, + { + "mutex_wait_ns": 2428800, + "serialization_ns": 29000, + "serialized_bytes": 612, + "statement_ns": 3125300, + "success": true + }, + { + "mutex_wait_ns": 3111600, + "serialization_ns": 32300, + "serialized_bytes": 612, + "statement_ns": 2991300, + "success": true + }, + { + "mutex_wait_ns": 2985100, + "serialization_ns": 32600, + "serialized_bytes": 612, + "statement_ns": 2581800, + "success": true + }, + { + "mutex_wait_ns": 2538000, + "serialization_ns": 49800, + "serialized_bytes": 1038, + "statement_ns": 3193100, + "success": true + }, + { + "mutex_wait_ns": 3138000, + "serialization_ns": 48900, + "serialized_bytes": 1038, + "statement_ns": 2703900, + "success": true + }, + { + "mutex_wait_ns": 2631300, + "serialization_ns": 51100, + "serialized_bytes": 1077, + "statement_ns": 2625500, + "success": true + }, + { + "mutex_wait_ns": 2564800, + "serialization_ns": 50900, + "serialized_bytes": 1077, + "statement_ns": 2492200, + "success": true + }, + { + "mutex_wait_ns": 2448200, + "serialization_ns": 54000, + "serialized_bytes": 1085, + "statement_ns": 2934500, + "success": true + }, + { + "mutex_wait_ns": 2894200, + "serialization_ns": 53300, + "serialized_bytes": 1085, + "statement_ns": 4274700, + "success": true + }, + { + "mutex_wait_ns": 4206200, + "serialization_ns": 60100, + "serialized_bytes": 1301, + "statement_ns": 3252900, + "success": true + }, + { + "mutex_wait_ns": 3192400, + "serialization_ns": 60300, + "serialized_bytes": 1301, + "statement_ns": 3329400, + "success": true + }, + { + "mutex_wait_ns": 3005300, + "serialization_ns": 28900, + "serialized_bytes": 612, + "statement_ns": 3060000, + "success": true + }, + { + "mutex_wait_ns": 2795900, + "serialization_ns": 29400, + "serialized_bytes": 610, + "statement_ns": 4004800, + "success": true + }, + { + "mutex_wait_ns": 4001400, + "serialization_ns": 31400, + "serialized_bytes": 612, + "statement_ns": 4035500, + "success": true + }, + { + "mutex_wait_ns": 3896300, + "serialization_ns": 165300, + "serialized_bytes": 610, + "statement_ns": 3068800, + "success": true + }, + { + "mutex_wait_ns": 3016000, + "serialization_ns": 50900, + "serialized_bytes": 1038, + "statement_ns": 2749300, + "success": true + }, + { + "mutex_wait_ns": 2702200, + "serialization_ns": 49000, + "serialized_bytes": 1034, + "statement_ns": 2441200, + "success": true + }, + { + "mutex_wait_ns": 2358000, + "serialization_ns": 54000, + "serialized_bytes": 1077, + "statement_ns": 3409500, + "success": true + }, + { + "mutex_wait_ns": 3356300, + "serialization_ns": 53000, + "serialized_bytes": 1073, + "statement_ns": 3145100, + "success": true + }, + { + "mutex_wait_ns": 3072200, + "serialization_ns": 79900, + "serialized_bytes": 1085, + "statement_ns": 3060400, + "success": true + }, + { + "mutex_wait_ns": 3009500, + "serialization_ns": 55000, + "serialized_bytes": 1081, + "statement_ns": 2845600, + "success": true + }, + { + "mutex_wait_ns": 2762600, + "serialization_ns": 63900, + "serialized_bytes": 1301, + "statement_ns": 3101600, + "success": true + }, + { + "mutex_wait_ns": 3029800, + "serialization_ns": 69200, + "serialized_bytes": 1297, + "statement_ns": 6725100, + "success": true + }, + { + "mutex_wait_ns": 6410400, + "serialization_ns": 29100, + "serialized_bytes": 612, + "statement_ns": 3377900, + "success": true + }, + { + "mutex_wait_ns": 3048500, + "serialization_ns": 33800, + "serialized_bytes": 610, + "statement_ns": 3815800, + "success": true + }, + { + "mutex_wait_ns": 3801600, + "serialization_ns": 36300, + "serialized_bytes": 612, + "statement_ns": 3128600, + "success": true + }, + { + "mutex_wait_ns": 3122000, + "serialization_ns": 36300, + "serialized_bytes": 610, + "statement_ns": 2949500, + "success": true + }, + { + "mutex_wait_ns": 2899800, + "serialization_ns": 51800, + "serialized_bytes": 1038, + "statement_ns": 2464700, + "success": true + }, + { + "mutex_wait_ns": 2426500, + "serialization_ns": 50700, + "serialized_bytes": 1034, + "statement_ns": 2820300, + "success": true + }, + { + "mutex_wait_ns": 2735200, + "serialization_ns": 52700, + "serialized_bytes": 1077, + "statement_ns": 2510600, + "success": true + }, + { + "mutex_wait_ns": 2424200, + "serialization_ns": 53300, + "serialized_bytes": 1073, + "statement_ns": 3340100, + "success": true + }, + { + "mutex_wait_ns": 3290400, + "serialization_ns": 54100, + "serialized_bytes": 1085, + "statement_ns": 2967100, + "success": true + }, + { + "mutex_wait_ns": 2932500, + "serialization_ns": 54000, + "serialized_bytes": 1081, + "statement_ns": 2993900, + "success": true + }, + { + "mutex_wait_ns": 2927400, + "serialization_ns": 61800, + "serialized_bytes": 1301, + "statement_ns": 2979600, + "success": true + }, + { + "mutex_wait_ns": 2909700, + "serialization_ns": 61400, + "serialized_bytes": 1297, + "statement_ns": 3434300, + "success": true + }, + { + "mutex_wait_ns": 3086700, + "serialization_ns": 33600, + "serialized_bytes": 612, + "statement_ns": 3256000, + "success": true + }, + { + "mutex_wait_ns": 2977500, + "serialization_ns": 27900, + "serialized_bytes": 610, + "statement_ns": 2711400, + "success": true + }, + { + "mutex_wait_ns": 2704600, + "serialization_ns": 32600, + "serialized_bytes": 612, + "statement_ns": 2665100, + "success": true + }, + { + "mutex_wait_ns": 2660600, + "serialization_ns": 32500, + "serialized_bytes": 610, + "statement_ns": 2533400, + "success": true + }, + { + "mutex_wait_ns": 2485700, + "serialization_ns": 49400, + "serialized_bytes": 1038, + "statement_ns": 2523300, + "success": true + }, + { + "mutex_wait_ns": 2470200, + "serialization_ns": 48800, + "serialized_bytes": 1034, + "statement_ns": 2663700, + "success": true + }, + { + "mutex_wait_ns": 2582300, + "serialization_ns": 52500, + "serialized_bytes": 1077, + "statement_ns": 2456900, + "success": true + }, + { + "mutex_wait_ns": 2391700, + "serialization_ns": 51900, + "serialized_bytes": 1073, + "statement_ns": 3137500, + "success": true + }, + { + "mutex_wait_ns": 3090200, + "serialization_ns": 53900, + "serialized_bytes": 1085, + "statement_ns": 3068300, + "success": true + }, + { + "mutex_wait_ns": 3031800, + "serialization_ns": 53200, + "serialized_bytes": 1081, + "statement_ns": 2794300, + "success": true + }, + { + "mutex_wait_ns": 2718700, + "serialization_ns": 62300, + "serialized_bytes": 1301, + "statement_ns": 2838600, + "success": true + }, + { + "mutex_wait_ns": 2773900, + "serialization_ns": 61600, + "serialized_bytes": 1297, + "statement_ns": 4355800, + "success": true + }, + { + "mutex_wait_ns": 4020600, + "serialization_ns": 30100, + "serialized_bytes": 610, + "statement_ns": 4150100, + "success": true + }, + { + "mutex_wait_ns": 3381100, + "serialization_ns": 32900, + "serialized_bytes": 612, + "statement_ns": 3438100, + "success": true + }, + { + "mutex_wait_ns": 3439900, + "serialization_ns": 35500, + "serialized_bytes": 610, + "statement_ns": 2570300, + "success": true + }, + { + "mutex_wait_ns": 2567600, + "serialization_ns": 41700, + "serialized_bytes": 612, + "statement_ns": 2455800, + "success": true + }, + { + "mutex_wait_ns": 2416700, + "serialization_ns": 51600, + "serialized_bytes": 1034, + "statement_ns": 2668200, + "success": true + }, + { + "mutex_wait_ns": 2619900, + "serialization_ns": 50200, + "serialized_bytes": 1038, + "statement_ns": 3009500, + "success": true + }, + { + "mutex_wait_ns": 2928800, + "serialization_ns": 52600, + "serialized_bytes": 1073, + "statement_ns": 3376800, + "success": true + }, + { + "mutex_wait_ns": 3273200, + "serialization_ns": 56400, + "serialized_bytes": 1077, + "statement_ns": 2579200, + "success": true + }, + { + "mutex_wait_ns": 2525700, + "serialization_ns": 53900, + "serialized_bytes": 1081, + "statement_ns": 3773100, + "success": true + }, + { + "mutex_wait_ns": 3728700, + "serialization_ns": 55600, + "serialized_bytes": 1085, + "statement_ns": 2459200, + "success": true + }, + { + "mutex_wait_ns": 2387900, + "serialization_ns": 60900, + "serialized_bytes": 1297, + "statement_ns": 3792800, + "success": true + }, + { + "mutex_wait_ns": 3734900, + "serialization_ns": 61100, + "serialized_bytes": 1301, + "statement_ns": 2991100, + "success": true + }, + { + "mutex_wait_ns": 2661000, + "serialization_ns": 29200, + "serialized_bytes": 612, + "statement_ns": 4707400, + "success": true + }, + { + "mutex_wait_ns": 4458500, + "serialization_ns": 31300, + "serialized_bytes": 612, + "statement_ns": 3979600, + "success": true + }, + { + "mutex_wait_ns": 3976600, + "serialization_ns": 33300, + "serialized_bytes": 612, + "statement_ns": 4549500, + "success": true + }, + { + "mutex_wait_ns": 4560100, + "serialization_ns": 32300, + "serialized_bytes": 612, + "statement_ns": 2659100, + "success": true + }, + { + "mutex_wait_ns": 2568500, + "serialization_ns": 81600, + "serialized_bytes": 1038, + "statement_ns": 2671300, + "success": true + }, + { + "mutex_wait_ns": 2627100, + "serialization_ns": 49500, + "serialized_bytes": 1038, + "statement_ns": 2664600, + "success": true + }, + { + "mutex_wait_ns": 2580700, + "serialization_ns": 54200, + "serialized_bytes": 1077, + "statement_ns": 2713500, + "success": true + }, + { + "mutex_wait_ns": 2643900, + "serialization_ns": 52100, + "serialized_bytes": 1077, + "statement_ns": 6441600, + "success": true + }, + { + "mutex_wait_ns": 6390800, + "serialization_ns": 56900, + "serialized_bytes": 1085, + "statement_ns": 2795400, + "success": true + }, + { + "mutex_wait_ns": 2738600, + "serialization_ns": 62600, + "serialized_bytes": 1085, + "statement_ns": 2680700, + "success": true + }, + { + "mutex_wait_ns": 2597000, + "serialization_ns": 64000, + "serialized_bytes": 1301, + "statement_ns": 3085700, + "success": true + }, + { + "mutex_wait_ns": 3018200, + "serialization_ns": 61900, + "serialized_bytes": 1301, + "statement_ns": 2474300, + "success": true + }, + { + "mutex_wait_ns": 2126300, + "serialization_ns": 29400, + "serialized_bytes": 612, + "statement_ns": 2844700, + "success": true + }, + { + "mutex_wait_ns": 2609400, + "serialization_ns": 27300, + "serialized_bytes": 610, + "statement_ns": 3485300, + "success": true + }, + { + "mutex_wait_ns": 3476600, + "serialization_ns": 33100, + "serialized_bytes": 612, + "statement_ns": 2612700, + "success": true + }, + { + "mutex_wait_ns": 2607000, + "serialization_ns": 31900, + "serialized_bytes": 610, + "statement_ns": 2736100, + "success": true + }, + { + "mutex_wait_ns": 2688200, + "serialization_ns": 48800, + "serialized_bytes": 1038, + "statement_ns": 2871500, + "success": true + }, + { + "mutex_wait_ns": 2828300, + "serialization_ns": 47700, + "serialized_bytes": 1034, + "statement_ns": 3506100, + "success": true + }, + { + "mutex_wait_ns": 3425900, + "serialization_ns": 54500, + "serialized_bytes": 1077, + "statement_ns": 2954700, + "success": true + }, + { + "mutex_wait_ns": 2898500, + "serialization_ns": 50900, + "serialized_bytes": 1073, + "statement_ns": 2740500, + "success": true + }, + { + "mutex_wait_ns": 2697400, + "serialization_ns": 53500, + "serialized_bytes": 1085, + "statement_ns": 3118800, + "success": true + }, + { + "mutex_wait_ns": 3077400, + "serialization_ns": 53900, + "serialized_bytes": 1081, + "statement_ns": 2703200, + "success": true + }, + { + "mutex_wait_ns": 2629300, + "serialization_ns": 60100, + "serialized_bytes": 1301, + "statement_ns": 3276000, + "success": true + }, + { + "mutex_wait_ns": 3209200, + "serialization_ns": 60100, + "serialized_bytes": 1297, + "statement_ns": 2795300, + "success": true + }, + { + "mutex_wait_ns": 2474200, + "serialization_ns": 28500, + "serialized_bytes": 612, + "statement_ns": 3001900, + "success": true + }, + { + "mutex_wait_ns": 2699100, + "serialization_ns": 35200, + "serialized_bytes": 610, + "statement_ns": 3722800, + "success": true + }, + { + "mutex_wait_ns": 3715700, + "serialization_ns": 32400, + "serialized_bytes": 612, + "statement_ns": 2781800, + "success": true + }, + { + "mutex_wait_ns": 2771500, + "serialization_ns": 39500, + "serialized_bytes": 610, + "statement_ns": 3267300, + "success": true + }, + { + "mutex_wait_ns": 3227000, + "serialization_ns": 50600, + "serialized_bytes": 1038, + "statement_ns": 2733700, + "success": true + }, + { + "mutex_wait_ns": 2692200, + "serialization_ns": 60600, + "serialized_bytes": 1034, + "statement_ns": 2636800, + "success": true + }, + { + "mutex_wait_ns": 2576100, + "serialization_ns": 54500, + "serialized_bytes": 1077, + "statement_ns": 2585300, + "success": true + }, + { + "mutex_wait_ns": 2486700, + "serialization_ns": 80500, + "serialized_bytes": 1073, + "statement_ns": 2916300, + "success": true + }, + { + "mutex_wait_ns": 2870100, + "serialization_ns": 54200, + "serialized_bytes": 1085, + "statement_ns": 2550300, + "success": true + }, + { + "mutex_wait_ns": 2506500, + "serialization_ns": 54700, + "serialized_bytes": 1081, + "statement_ns": 2851900, + "success": true + }, + { + "mutex_wait_ns": 2780900, + "serialization_ns": 61300, + "serialized_bytes": 1301, + "statement_ns": 2903200, + "success": true + }, + { + "mutex_wait_ns": 2844400, + "serialization_ns": 60200, + "serialized_bytes": 1297, + "statement_ns": 2686400, + "success": true + }, + { + "mutex_wait_ns": 2361200, + "serialization_ns": 30700, + "serialized_bytes": 610, + "statement_ns": 2983800, + "success": true + }, + { + "mutex_wait_ns": 2745100, + "serialization_ns": 29300, + "serialized_bytes": 612, + "statement_ns": 3181600, + "success": true + }, + { + "mutex_wait_ns": 3172100, + "serialization_ns": 32900, + "serialized_bytes": 610, + "statement_ns": 2340900, + "success": true + }, + { + "mutex_wait_ns": 2331400, + "serialization_ns": 33200, + "serialized_bytes": 612, + "statement_ns": 2676200, + "success": true + }, + { + "mutex_wait_ns": 2627600, + "serialization_ns": 50100, + "serialized_bytes": 1034, + "statement_ns": 2952900, + "success": true + }, + { + "mutex_wait_ns": 2896600, + "serialization_ns": 61700, + "serialized_bytes": 1038, + "statement_ns": 2545800, + "success": true + }, + { + "mutex_wait_ns": 2436500, + "serialization_ns": 83400, + "serialized_bytes": 1073, + "statement_ns": 2766900, + "success": true + }, + { + "mutex_wait_ns": 2704000, + "serialization_ns": 51900, + "serialized_bytes": 1077, + "statement_ns": 2575800, + "success": true + }, + { + "mutex_wait_ns": 2527500, + "serialization_ns": 53900, + "serialized_bytes": 1081, + "statement_ns": 4342700, + "success": true + }, + { + "mutex_wait_ns": 4298400, + "serialization_ns": 53500, + "serialized_bytes": 1085, + "statement_ns": 3114900, + "success": true + }, + { + "mutex_wait_ns": 2984100, + "serialization_ns": 98500, + "serialized_bytes": 1297, + "statement_ns": 3113500, + "success": true + }, + { + "mutex_wait_ns": 3027600, + "serialization_ns": 60000, + "serialized_bytes": 1301, + "statement_ns": 2470600, + "success": true + }, + { + "mutex_wait_ns": 2137700, + "serialization_ns": 28200, + "serialized_bytes": 612, + "statement_ns": 3208700, + "success": true + }, + { + "mutex_wait_ns": 2708000, + "serialization_ns": 28400, + "serialized_bytes": 612, + "statement_ns": 2981600, + "success": true + }, + { + "mutex_wait_ns": 2975200, + "serialization_ns": 31900, + "serialized_bytes": 612, + "statement_ns": 3370000, + "success": true + }, + { + "mutex_wait_ns": 3370300, + "serialization_ns": 32400, + "serialized_bytes": 612, + "statement_ns": 2445700, + "success": true + }, + { + "mutex_wait_ns": 2403000, + "serialization_ns": 49100, + "serialized_bytes": 1038, + "statement_ns": 2926200, + "success": true + }, + { + "mutex_wait_ns": 2878400, + "serialization_ns": 49100, + "serialized_bytes": 1038, + "statement_ns": 3347200, + "success": true + }, + { + "mutex_wait_ns": 3265700, + "serialization_ns": 55400, + "serialized_bytes": 1077, + "statement_ns": 2563200, + "success": true + }, + { + "mutex_wait_ns": 2499300, + "serialization_ns": 51800, + "serialized_bytes": 1077, + "statement_ns": 2563000, + "success": true + }, + { + "mutex_wait_ns": 2514300, + "serialization_ns": 54600, + "serialized_bytes": 1085, + "statement_ns": 2753300, + "success": true + }, + { + "mutex_wait_ns": 2710100, + "serialization_ns": 54600, + "serialized_bytes": 1085, + "statement_ns": 5062700, + "success": true + }, + { + "mutex_wait_ns": 4934000, + "serialization_ns": 98600, + "serialized_bytes": 1301, + "statement_ns": 4554800, + "success": true + }, + { + "mutex_wait_ns": 4486600, + "serialization_ns": 62500, + "serialized_bytes": 1301, + "statement_ns": 3389200, + "success": true + }, + { + "mutex_wait_ns": 3065800, + "serialization_ns": 29500, + "serialized_bytes": 610, + "statement_ns": 3483300, + "success": true + }, + { + "mutex_wait_ns": 3178400, + "serialization_ns": 35800, + "serialized_bytes": 612, + "statement_ns": 3092400, + "success": true + }, + { + "mutex_wait_ns": 3092800, + "serialization_ns": 34200, + "serialized_bytes": 610, + "statement_ns": 2878500, + "success": true + }, + { + "mutex_wait_ns": 2870800, + "serialization_ns": 40700, + "serialized_bytes": 612, + "statement_ns": 2473500, + "success": true + }, + { + "mutex_wait_ns": 2382800, + "serialization_ns": 80400, + "serialized_bytes": 1034, + "statement_ns": 2736100, + "success": true + }, + { + "mutex_wait_ns": 2652700, + "serialization_ns": 79600, + "serialized_bytes": 1038, + "statement_ns": 38682800, + "success": true + }, + { + "mutex_wait_ns": 38602500, + "serialization_ns": 54000, + "serialized_bytes": 1073, + "statement_ns": 3477800, + "success": true + }, + { + "mutex_wait_ns": 3377900, + "serialization_ns": 67900, + "serialized_bytes": 1077, + "statement_ns": 2774500, + "success": true + }, + { + "mutex_wait_ns": 2714600, + "serialization_ns": 64100, + "serialized_bytes": 1081, + "statement_ns": 2733600, + "success": true + }, + { + "mutex_wait_ns": 2687200, + "serialization_ns": 58500, + "serialized_bytes": 1085, + "statement_ns": 3031100, + "success": true + }, + { + "mutex_wait_ns": 2945200, + "serialization_ns": 74900, + "serialized_bytes": 1297, + "statement_ns": 2798300, + "success": true + }, + { + "mutex_wait_ns": 2743100, + "serialization_ns": 61300, + "serialized_bytes": 1301, + "statement_ns": 2391400, + "success": true + }, + { + "mutex_wait_ns": 2031500, + "serialization_ns": 35000, + "serialized_bytes": 612, + "statement_ns": 3888300, + "success": true + }, + { + "mutex_wait_ns": 3624700, + "serialization_ns": 29400, + "serialized_bytes": 612, + "statement_ns": 7264100, + "success": true + }, + { + "mutex_wait_ns": 7248300, + "serialization_ns": 38400, + "serialized_bytes": 612, + "statement_ns": 2366800, + "success": true + }, + { + "mutex_wait_ns": 2355500, + "serialization_ns": 35700, + "serialized_bytes": 612, + "statement_ns": 2342200, + "success": true + }, + { + "mutex_wait_ns": 2274900, + "serialization_ns": 62200, + "serialized_bytes": 1038, + "statement_ns": 2330500, + "success": true + }, + { + "mutex_wait_ns": 2289000, + "serialization_ns": 49400, + "serialized_bytes": 1038, + "statement_ns": 6962000, + "success": true + }, + { + "mutex_wait_ns": 6871000, + "serialization_ns": 62700, + "serialized_bytes": 1077, + "statement_ns": 2723700, + "success": true + }, + { + "mutex_wait_ns": 2646000, + "serialization_ns": 57900, + "serialized_bytes": 1077, + "statement_ns": 2556500, + "success": true + }, + { + "mutex_wait_ns": 2503400, + "serialization_ns": 56200, + "serialized_bytes": 1085, + "statement_ns": 2361000, + "success": true + }, + { + "mutex_wait_ns": 2314700, + "serialization_ns": 56100, + "serialized_bytes": 1085, + "statement_ns": 2444100, + "success": true + }, + { + "mutex_wait_ns": 2375400, + "serialization_ns": 59800, + "serialized_bytes": 1301, + "statement_ns": 4897500, + "success": true + }, + { + "mutex_wait_ns": 4846400, + "serialization_ns": 60300, + "serialized_bytes": 1301, + "statement_ns": 2725700, + "success": true + }, + { + "mutex_wait_ns": 2406900, + "serialization_ns": 30000, + "serialized_bytes": 612, + "statement_ns": 2771200, + "success": true + }, + { + "mutex_wait_ns": 2511100, + "serialization_ns": 28300, + "serialized_bytes": 612, + "statement_ns": 3177100, + "success": true + }, + { + "mutex_wait_ns": 3165200, + "serialization_ns": 33900, + "serialized_bytes": 612, + "statement_ns": 4385400, + "success": true + }, + { + "mutex_wait_ns": 4382400, + "serialization_ns": 32400, + "serialized_bytes": 612, + "statement_ns": 2831200, + "success": true + }, + { + "mutex_wait_ns": 2778300, + "serialization_ns": 54100, + "serialized_bytes": 1038, + "statement_ns": 2624700, + "success": true + }, + { + "mutex_wait_ns": 2575400, + "serialization_ns": 49400, + "serialized_bytes": 1038, + "statement_ns": 2666100, + "success": true + }, + { + "mutex_wait_ns": 2579700, + "serialization_ns": 54600, + "serialized_bytes": 1077, + "statement_ns": 2375700, + "success": true + }, + { + "mutex_wait_ns": 2279900, + "serialization_ns": 71100, + "serialized_bytes": 1077, + "statement_ns": 2973000, + "success": true + }, + { + "mutex_wait_ns": 2922500, + "serialization_ns": 54900, + "serialized_bytes": 1085, + "statement_ns": 2608000, + "success": true + }, + { + "mutex_wait_ns": 2550400, + "serialization_ns": 67500, + "serialized_bytes": 1085, + "statement_ns": 2794300, + "success": true + }, + { + "mutex_wait_ns": 2723600, + "serialization_ns": 59800, + "serialized_bytes": 1301, + "statement_ns": 2651700, + "success": true + }, + { + "mutex_wait_ns": 2566600, + "serialization_ns": 75500, + "serialized_bytes": 1301, + "statement_ns": 2511100, + "success": true + }, + { + "mutex_wait_ns": 2190700, + "serialization_ns": 28400, + "serialized_bytes": 612, + "statement_ns": 2612600, + "success": true + }, + { + "mutex_wait_ns": 2329100, + "serialization_ns": 34900, + "serialized_bytes": 610, + "statement_ns": 3109300, + "success": true + }, + { + "mutex_wait_ns": 3103000, + "serialization_ns": 31700, + "serialized_bytes": 612, + "statement_ns": 2613600, + "success": true + }, + { + "mutex_wait_ns": 2606800, + "serialization_ns": 39000, + "serialized_bytes": 610, + "statement_ns": 2853700, + "success": true + }, + { + "mutex_wait_ns": 2817000, + "serialization_ns": 48400, + "serialized_bytes": 1038, + "statement_ns": 2476900, + "success": true + }, + { + "mutex_wait_ns": 2431500, + "serialization_ns": 48600, + "serialized_bytes": 1034, + "statement_ns": 3421000, + "success": true + }, + { + "mutex_wait_ns": 3352300, + "serialization_ns": 51000, + "serialized_bytes": 1077, + "statement_ns": 2447000, + "success": true + }, + { + "mutex_wait_ns": 2383100, + "serialization_ns": 51300, + "serialized_bytes": 1073, + "statement_ns": 2388400, + "success": true + }, + { + "mutex_wait_ns": 2344200, + "serialization_ns": 52400, + "serialized_bytes": 1085, + "statement_ns": 2596800, + "success": true + }, + { + "mutex_wait_ns": 2561800, + "serialization_ns": 52000, + "serialized_bytes": 1081, + "statement_ns": 2825700, + "success": true + }, + { + "mutex_wait_ns": 2760700, + "serialization_ns": 59900, + "serialized_bytes": 1301, + "statement_ns": 6119600, + "success": true + }, + { + "mutex_wait_ns": 6102600, + "serialization_ns": 59400, + "serialized_bytes": 1297, + "statement_ns": 3623200, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 3898500, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=0", + "COMPILER=msvc-1944", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_W32", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "HTTP", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 721823800, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 243891000, + 244024800, + 243625200, + 243726600, + 243556900, + 243405500, + 243482400, + 243335400, + 243419600, + 243280100, + 243328500, + 242670500, + 583482200, + 582654700, + 582579800, + 582617400, + 716929000, + 714910900, + 714827200, + 714779700, + 717275300, + 717115800, + 717177300, + 717033000, + 717154500, + 716924400, + 716916100, + 716902800, + 716846000, + 716803000, + 716735000, + 718104500 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 3745900, + 228060900, + 329913800, + 125605700, + 458900, + 422400, + 765000 + ], + "failures": 0, + "in_window_samples": 4, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 3745900, + "end_ns": 14773100, + "in_window": true, + "scheduled_ns": null, + "start_ns": 11027200, + "success": true + }, + { + "elapsed_ns": 228060900, + "end_ns": 253152600, + "in_window": true, + "scheduled_ns": null, + "start_ns": 25091700, + "success": true + }, + { + "elapsed_ns": 329913800, + "end_ns": 593402500, + "in_window": true, + "scheduled_ns": null, + "start_ns": 263488700, + "success": true + }, + { + "elapsed_ns": 125605700, + "end_ns": 729154300, + "in_window": true, + "scheduled_ns": null, + "start_ns": 603548600, + "success": true + }, + { + "elapsed_ns": 458900, + "end_ns": 740162800, + "in_window": false, + "scheduled_ns": null, + "start_ns": 739703900, + "success": true + }, + { + "elapsed_ns": 422400, + "end_ns": 750754300, + "in_window": false, + "scheduled_ns": null, + "start_ns": 750331900, + "success": true + }, + { + "elapsed_ns": 765000, + "end_ns": 761671700, + "in_window": false, + "scheduled_ns": null, + "start_ns": 760906700, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 233796500, + 81472400, + 379236700, + 742900, + 851700, + 1454300, + 1814300 + ], + "failures": 0, + "in_window_samples": 4, + "missed_periods": 68, + "samples": [ + { + "elapsed_ns": 233796500, + "end_ns": 252944400, + "in_window": true, + "scheduled_ns": 19147900, + "start_ns": 252944400, + "success": true + }, + { + "elapsed_ns": 81472400, + "end_ns": 340620300, + "in_window": true, + "scheduled_ns": 259147900, + "start_ns": 340620300, + "success": true + }, + { + "elapsed_ns": 379236700, + "end_ns": 728384600, + "in_window": true, + "scheduled_ns": 349147900, + "start_ns": 728384600, + "success": true + }, + { + "elapsed_ns": 742900, + "end_ns": 729890800, + "in_window": true, + "scheduled_ns": 729147900, + "start_ns": 729890800, + "success": true + }, + { + "elapsed_ns": 851700, + "end_ns": 739999600, + "in_window": false, + "scheduled_ns": 739147900, + "start_ns": 739999600, + "success": true + }, + { + "elapsed_ns": 1454300, + "end_ns": 750602200, + "in_window": false, + "scheduled_ns": 749147900, + "start_ns": 750602200, + "success": true + }, + { + "elapsed_ns": 1814300, + "end_ns": 760962200, + "in_window": false, + "scheduled_ns": 759147900, + "start_ns": 760962200, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 731003500, + "window_start_ns": 9179700 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 1, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 700, + "serialization_ns": 53900, + "serialized_bytes": 610, + "statement_ns": 4553700, + "success": true + }, + { + "mutex_wait_ns": 4049200, + "serialization_ns": 71500, + "serialized_bytes": 612, + "statement_ns": 3451400, + "success": true + }, + { + "mutex_wait_ns": 3449200, + "serialization_ns": 37300, + "serialized_bytes": 610, + "statement_ns": 2500000, + "success": true + }, + { + "mutex_wait_ns": 2486500, + "serialization_ns": 37500, + "serialized_bytes": 612, + "statement_ns": 4485900, + "success": true + }, + { + "mutex_wait_ns": 4424500, + "serialization_ns": 54000, + "serialized_bytes": 1034, + "statement_ns": 2697800, + "success": true + }, + { + "mutex_wait_ns": 2649800, + "serialization_ns": 53900, + "serialized_bytes": 1038, + "statement_ns": 4231800, + "success": true + }, + { + "mutex_wait_ns": 4149300, + "serialization_ns": 57600, + "serialized_bytes": 1073, + "statement_ns": 3136100, + "success": true + }, + { + "mutex_wait_ns": 3062600, + "serialization_ns": 56700, + "serialized_bytes": 1077, + "statement_ns": 2659600, + "success": true + }, + { + "mutex_wait_ns": 2602500, + "serialization_ns": 56900, + "serialized_bytes": 1081, + "statement_ns": 2906000, + "success": true + }, + { + "mutex_wait_ns": 2861300, + "serialization_ns": 55900, + "serialized_bytes": 1085, + "statement_ns": 3577100, + "success": true + }, + { + "mutex_wait_ns": 3494000, + "serialization_ns": 63300, + "serialized_bytes": 1297, + "statement_ns": 2857800, + "success": true + }, + { + "mutex_wait_ns": 2795900, + "serialization_ns": 61300, + "serialized_bytes": 1301, + "statement_ns": 3056300, + "success": true + }, + { + "mutex_wait_ns": 2672700, + "serialization_ns": 30200, + "serialized_bytes": 610, + "statement_ns": 3325300, + "success": true + }, + { + "mutex_wait_ns": 3083100, + "serialization_ns": 29900, + "serialized_bytes": 610, + "statement_ns": 6058800, + "success": true + }, + { + "mutex_wait_ns": 6049800, + "serialization_ns": 32700, + "serialized_bytes": 610, + "statement_ns": 2966000, + "success": true + }, + { + "mutex_wait_ns": 2960600, + "serialization_ns": 33200, + "serialized_bytes": 610, + "statement_ns": 2655000, + "success": true + }, + { + "mutex_wait_ns": 2616400, + "serialization_ns": 50300, + "serialized_bytes": 1034, + "statement_ns": 2821400, + "success": true + }, + { + "mutex_wait_ns": 2784000, + "serialization_ns": 49900, + "serialized_bytes": 1034, + "statement_ns": 3313000, + "success": true + }, + { + "mutex_wait_ns": 3228000, + "serialization_ns": 55500, + "serialized_bytes": 1073, + "statement_ns": 3048900, + "success": true + }, + { + "mutex_wait_ns": 2971700, + "serialization_ns": 56600, + "serialized_bytes": 1073, + "statement_ns": 3406700, + "success": true + }, + { + "mutex_wait_ns": 3355100, + "serialization_ns": 57400, + "serialized_bytes": 1081, + "statement_ns": 2928600, + "success": true + }, + { + "mutex_wait_ns": 2887300, + "serialization_ns": 60600, + "serialized_bytes": 1081, + "statement_ns": 2665200, + "success": true + }, + { + "mutex_wait_ns": 2596100, + "serialization_ns": 63900, + "serialized_bytes": 1297, + "statement_ns": 3684600, + "success": true + }, + { + "mutex_wait_ns": 3620600, + "serialization_ns": 64200, + "serialized_bytes": 1297, + "statement_ns": 2817500, + "success": true + }, + { + "mutex_wait_ns": 2492300, + "serialization_ns": 30900, + "serialized_bytes": 610, + "statement_ns": 3331200, + "success": true + }, + { + "mutex_wait_ns": 3084100, + "serialization_ns": 30000, + "serialized_bytes": 610, + "statement_ns": 3115700, + "success": true + }, + { + "mutex_wait_ns": 3106100, + "serialization_ns": 34100, + "serialized_bytes": 610, + "statement_ns": 2712200, + "success": true + }, + { + "mutex_wait_ns": 2714600, + "serialization_ns": 34000, + "serialized_bytes": 610, + "statement_ns": 2701800, + "success": true + }, + { + "mutex_wait_ns": 2664600, + "serialization_ns": 51600, + "serialized_bytes": 1034, + "statement_ns": 2760900, + "success": true + }, + { + "mutex_wait_ns": 2716400, + "serialization_ns": 51500, + "serialized_bytes": 1034, + "statement_ns": 2973400, + "success": true + }, + { + "mutex_wait_ns": 2894900, + "serialization_ns": 52300, + "serialized_bytes": 1073, + "statement_ns": 2865300, + "success": true + }, + { + "mutex_wait_ns": 2801600, + "serialization_ns": 52900, + "serialized_bytes": 1073, + "statement_ns": 2673400, + "success": true + }, + { + "mutex_wait_ns": 2631900, + "serialization_ns": 53400, + "serialized_bytes": 1081, + "statement_ns": 2859700, + "success": true + }, + { + "mutex_wait_ns": 2819500, + "serialization_ns": 54700, + "serialized_bytes": 1081, + "statement_ns": 2461300, + "success": true + }, + { + "mutex_wait_ns": 2383600, + "serialization_ns": 60100, + "serialized_bytes": 1297, + "statement_ns": 3103500, + "success": true + }, + { + "mutex_wait_ns": 3043000, + "serialization_ns": 60200, + "serialized_bytes": 1297, + "statement_ns": 4068700, + "success": true + }, + { + "mutex_wait_ns": 3760100, + "serialization_ns": 29600, + "serialized_bytes": 612, + "statement_ns": 3759900, + "success": true + }, + { + "mutex_wait_ns": 3427100, + "serialization_ns": 30300, + "serialized_bytes": 610, + "statement_ns": 3522400, + "success": true + }, + { + "mutex_wait_ns": 3509600, + "serialization_ns": 34900, + "serialized_bytes": 612, + "statement_ns": 3032200, + "success": true + }, + { + "mutex_wait_ns": 3023200, + "serialization_ns": 33400, + "serialized_bytes": 610, + "statement_ns": 3162500, + "success": true + }, + { + "mutex_wait_ns": 3115600, + "serialization_ns": 51100, + "serialized_bytes": 1038, + "statement_ns": 2963100, + "success": true + }, + { + "mutex_wait_ns": 2919600, + "serialization_ns": 49300, + "serialized_bytes": 1034, + "statement_ns": 3023100, + "success": true + }, + { + "mutex_wait_ns": 2934600, + "serialization_ns": 57600, + "serialized_bytes": 1077, + "statement_ns": 3740600, + "success": true + }, + { + "mutex_wait_ns": 3683400, + "serialization_ns": 52000, + "serialized_bytes": 1073, + "statement_ns": 2585200, + "success": true + }, + { + "mutex_wait_ns": 2532100, + "serialization_ns": 57000, + "serialized_bytes": 1085, + "statement_ns": 3644700, + "success": true + }, + { + "mutex_wait_ns": 3603600, + "serialization_ns": 54400, + "serialized_bytes": 1081, + "statement_ns": 3061200, + "success": true + }, + { + "mutex_wait_ns": 2989700, + "serialization_ns": 60100, + "serialized_bytes": 1301, + "statement_ns": 3329000, + "success": true + }, + { + "mutex_wait_ns": 3253000, + "serialization_ns": 77400, + "serialized_bytes": 1297, + "statement_ns": 2891600, + "success": true + }, + { + "mutex_wait_ns": 2592200, + "serialization_ns": 30500, + "serialized_bytes": 612, + "statement_ns": 3562300, + "success": true + }, + { + "mutex_wait_ns": 3321600, + "serialization_ns": 29900, + "serialized_bytes": 612, + "statement_ns": 4092700, + "success": true + }, + { + "mutex_wait_ns": 4083500, + "serialization_ns": 33000, + "serialized_bytes": 612, + "statement_ns": 6123600, + "success": true + }, + { + "mutex_wait_ns": 6126800, + "serialization_ns": 33000, + "serialized_bytes": 612, + "statement_ns": 2654200, + "success": true + }, + { + "mutex_wait_ns": 2613500, + "serialization_ns": 52500, + "serialized_bytes": 1038, + "statement_ns": 2748500, + "success": true + }, + { + "mutex_wait_ns": 2704700, + "serialization_ns": 50500, + "serialized_bytes": 1038, + "statement_ns": 3143000, + "success": true + }, + { + "mutex_wait_ns": 3059000, + "serialization_ns": 56000, + "serialized_bytes": 1077, + "statement_ns": 3195300, + "success": true + }, + { + "mutex_wait_ns": 3119400, + "serialization_ns": 57300, + "serialized_bytes": 1077, + "statement_ns": 2766600, + "success": true + }, + { + "mutex_wait_ns": 2723300, + "serialization_ns": 57900, + "serialized_bytes": 1085, + "statement_ns": 2630400, + "success": true + }, + { + "mutex_wait_ns": 2600500, + "serialization_ns": 57500, + "serialized_bytes": 1085, + "statement_ns": 2661400, + "success": true + }, + { + "mutex_wait_ns": 2555700, + "serialization_ns": 80800, + "serialized_bytes": 1301, + "statement_ns": 3358900, + "success": true + }, + { + "mutex_wait_ns": 3295300, + "serialization_ns": 62200, + "serialized_bytes": 1301, + "statement_ns": 3659500, + "success": true + }, + { + "mutex_wait_ns": 3290600, + "serialization_ns": 37600, + "serialized_bytes": 610, + "statement_ns": 3587900, + "success": true + }, + { + "mutex_wait_ns": 2719300, + "serialization_ns": 31400, + "serialized_bytes": 612, + "statement_ns": 3764300, + "success": true + }, + { + "mutex_wait_ns": 3751500, + "serialization_ns": 39200, + "serialized_bytes": 610, + "statement_ns": 2724100, + "success": true + }, + { + "mutex_wait_ns": 2718300, + "serialization_ns": 34400, + "serialized_bytes": 612, + "statement_ns": 3151600, + "success": true + }, + { + "mutex_wait_ns": 3091600, + "serialization_ns": 61200, + "serialized_bytes": 1034, + "statement_ns": 2938800, + "success": true + }, + { + "mutex_wait_ns": 2895500, + "serialization_ns": 50500, + "serialized_bytes": 1038, + "statement_ns": 3307900, + "success": true + }, + { + "mutex_wait_ns": 3218100, + "serialization_ns": 53000, + "serialized_bytes": 1073, + "statement_ns": 2982200, + "success": true + }, + { + "mutex_wait_ns": 2913500, + "serialization_ns": 55000, + "serialized_bytes": 1077, + "statement_ns": 3333900, + "success": true + }, + { + "mutex_wait_ns": 3290100, + "serialization_ns": 56000, + "serialized_bytes": 1081, + "statement_ns": 3089600, + "success": true + }, + { + "mutex_wait_ns": 3051900, + "serialization_ns": 60200, + "serialized_bytes": 1085, + "statement_ns": 4377600, + "success": true + }, + { + "mutex_wait_ns": 4308400, + "serialization_ns": 62100, + "serialized_bytes": 1297, + "statement_ns": 3202100, + "success": true + }, + { + "mutex_wait_ns": 3127300, + "serialization_ns": 65300, + "serialized_bytes": 1301, + "statement_ns": 3331100, + "success": true + }, + { + "mutex_wait_ns": 2968500, + "serialization_ns": 28900, + "serialized_bytes": 610, + "statement_ns": 3196400, + "success": true + }, + { + "mutex_wait_ns": 385100, + "serialization_ns": 29100, + "serialized_bytes": 612, + "statement_ns": 3109900, + "success": true + }, + { + "mutex_wait_ns": 3102400, + "serialization_ns": 31500, + "serialized_bytes": 610, + "statement_ns": 2773000, + "success": true + }, + { + "mutex_wait_ns": 2762100, + "serialization_ns": 32200, + "serialized_bytes": 612, + "statement_ns": 3033800, + "success": true + }, + { + "mutex_wait_ns": 2986900, + "serialization_ns": 50600, + "serialized_bytes": 1034, + "statement_ns": 3581000, + "success": true + }, + { + "mutex_wait_ns": 3541000, + "serialization_ns": 48400, + "serialized_bytes": 1038, + "statement_ns": 2999000, + "success": true + }, + { + "mutex_wait_ns": 2927100, + "serialization_ns": 52300, + "serialized_bytes": 1073, + "statement_ns": 3214900, + "success": true + }, + { + "mutex_wait_ns": 3159300, + "serialization_ns": 52100, + "serialized_bytes": 1077, + "statement_ns": 3108200, + "success": true + }, + { + "mutex_wait_ns": 3027800, + "serialization_ns": 84400, + "serialized_bytes": 1081, + "statement_ns": 3290200, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 60100, + "serialized_bytes": 1297, + "statement_ns": 3245500, + "success": true + }, + { + "mutex_wait_ns": 6569200, + "serialization_ns": 85400, + "serialized_bytes": 1085, + "statement_ns": 3555000, + "success": true + }, + { + "mutex_wait_ns": 3118300, + "serialization_ns": 28100, + "serialized_bytes": 612, + "statement_ns": 5499900, + "success": true + }, + { + "mutex_wait_ns": 5430700, + "serialization_ns": 60700, + "serialized_bytes": 1301, + "statement_ns": 3044100, + "success": true + }, + { + "mutex_wait_ns": 3002000, + "serialization_ns": 56900, + "serialized_bytes": 612, + "statement_ns": 3354800, + "success": true + }, + { + "mutex_wait_ns": 2459000, + "serialization_ns": 61900, + "serialized_bytes": 610, + "statement_ns": 3022600, + "success": true + }, + { + "mutex_wait_ns": 2979700, + "serialization_ns": 49400, + "serialized_bytes": 1038, + "statement_ns": 2899100, + "success": true + }, + { + "mutex_wait_ns": 2888100, + "serialization_ns": 32600, + "serialized_bytes": 610, + "statement_ns": 2870500, + "success": true + }, + { + "mutex_wait_ns": 2803400, + "serialization_ns": 51200, + "serialized_bytes": 1077, + "statement_ns": 3166100, + "success": true + }, + { + "mutex_wait_ns": 3070800, + "serialization_ns": 97700, + "serialized_bytes": 1034, + "statement_ns": 2944700, + "success": true + }, + { + "mutex_wait_ns": 2891400, + "serialization_ns": 55000, + "serialized_bytes": 1085, + "statement_ns": 2811600, + "success": true + }, + { + "mutex_wait_ns": 2732600, + "serialization_ns": 56100, + "serialized_bytes": 1073, + "statement_ns": 2935700, + "success": true + }, + { + "mutex_wait_ns": 2871500, + "serialization_ns": 59700, + "serialized_bytes": 1301, + "statement_ns": 3272200, + "success": true + }, + { + "mutex_wait_ns": 3229900, + "serialization_ns": 52500, + "serialized_bytes": 1081, + "statement_ns": 3325700, + "success": true + }, + { + "mutex_wait_ns": 2773100, + "serialization_ns": 45800, + "serialized_bytes": 612, + "statement_ns": 5416400, + "success": true + }, + { + "mutex_wait_ns": 5351100, + "serialization_ns": 62100, + "serialized_bytes": 1297, + "statement_ns": 7554400, + "success": true + }, + { + "mutex_wait_ns": 7536000, + "serialization_ns": 37600, + "serialized_bytes": 612, + "statement_ns": 5239200, + "success": true + }, + { + "mutex_wait_ns": 4718800, + "serialization_ns": 34100, + "serialized_bytes": 612, + "statement_ns": 5527300, + "success": true + }, + { + "mutex_wait_ns": 5489600, + "serialization_ns": 48800, + "serialized_bytes": 1038, + "statement_ns": 4355900, + "success": true + }, + { + "mutex_wait_ns": 4338300, + "serialization_ns": 36100, + "serialized_bytes": 612, + "statement_ns": 3487000, + "success": true + }, + { + "mutex_wait_ns": 3403100, + "serialization_ns": 55700, + "serialized_bytes": 1077, + "statement_ns": 3188500, + "success": true + }, + { + "mutex_wait_ns": 3138800, + "serialization_ns": 50500, + "serialized_bytes": 1038, + "statement_ns": 3090800, + "success": true + }, + { + "mutex_wait_ns": 3047300, + "serialization_ns": 52700, + "serialized_bytes": 1085, + "statement_ns": 3373100, + "success": true + }, + { + "mutex_wait_ns": 3306400, + "serialization_ns": 52200, + "serialized_bytes": 1077, + "statement_ns": 3684000, + "success": true + }, + { + "mutex_wait_ns": 3618100, + "serialization_ns": 59600, + "serialized_bytes": 1301, + "statement_ns": 6076300, + "success": true + }, + { + "mutex_wait_ns": 6030700, + "serialization_ns": 53100, + "serialized_bytes": 1085, + "statement_ns": 3926300, + "success": true + }, + { + "mutex_wait_ns": 3638000, + "serialization_ns": 29300, + "serialized_bytes": 612, + "statement_ns": 7407300, + "success": true + }, + { + "mutex_wait_ns": 7343400, + "serialization_ns": 61900, + "serialized_bytes": 1301, + "statement_ns": 3547300, + "success": true + }, + { + "mutex_wait_ns": 3534100, + "serialization_ns": 33500, + "serialized_bytes": 612, + "statement_ns": 5179400, + "success": true + }, + { + "mutex_wait_ns": 4897900, + "serialization_ns": 29200, + "serialized_bytes": 612, + "statement_ns": 6069200, + "success": true + }, + { + "mutex_wait_ns": 6022500, + "serialization_ns": 49500, + "serialized_bytes": 1038, + "statement_ns": 3050600, + "success": true + }, + { + "mutex_wait_ns": 3036400, + "serialization_ns": 33700, + "serialized_bytes": 612, + "statement_ns": 3818200, + "success": true + }, + { + "mutex_wait_ns": 3738600, + "serialization_ns": 54900, + "serialized_bytes": 1077, + "statement_ns": 7122900, + "success": true + }, + { + "mutex_wait_ns": 7074200, + "serialization_ns": 49300, + "serialized_bytes": 1038, + "statement_ns": 3631200, + "success": true + }, + { + "mutex_wait_ns": 3549700, + "serialization_ns": 83000, + "serialized_bytes": 1085, + "statement_ns": 3162600, + "success": true + }, + { + "mutex_wait_ns": 3064600, + "serialization_ns": 67700, + "serialized_bytes": 1077, + "statement_ns": 3998400, + "success": true + }, + { + "mutex_wait_ns": 3927700, + "serialization_ns": 64200, + "serialized_bytes": 1301, + "statement_ns": 3549000, + "success": true + }, + { + "mutex_wait_ns": 3503000, + "serialization_ns": 56200, + "serialized_bytes": 1085, + "statement_ns": 4003200, + "success": true + }, + { + "mutex_wait_ns": 3699700, + "serialization_ns": 33200, + "serialized_bytes": 612, + "statement_ns": 6111000, + "success": true + }, + { + "mutex_wait_ns": 6033200, + "serialization_ns": 66700, + "serialized_bytes": 1301, + "statement_ns": 7017000, + "success": true + }, + { + "mutex_wait_ns": 7002900, + "serialization_ns": 33700, + "serialized_bytes": 612, + "statement_ns": 3661500, + "success": true + }, + { + "mutex_wait_ns": 3330500, + "serialization_ns": 29300, + "serialized_bytes": 610, + "statement_ns": 4186900, + "success": true + }, + { + "mutex_wait_ns": 4141900, + "serialization_ns": 50400, + "serialized_bytes": 1038, + "statement_ns": 4809600, + "success": true + }, + { + "mutex_wait_ns": 4798900, + "serialization_ns": 34900, + "serialized_bytes": 610, + "statement_ns": 4420300, + "success": true + }, + { + "mutex_wait_ns": 4329900, + "serialization_ns": 56900, + "serialized_bytes": 1077, + "statement_ns": 4079000, + "success": true + }, + { + "mutex_wait_ns": 4026700, + "serialization_ns": 51600, + "serialized_bytes": 1034, + "statement_ns": 4088500, + "success": true + }, + { + "mutex_wait_ns": 4021900, + "serialization_ns": 70700, + "serialized_bytes": 1085, + "statement_ns": 6958400, + "success": true + }, + { + "mutex_wait_ns": 6888800, + "serialization_ns": 54000, + "serialized_bytes": 1073, + "statement_ns": 3392500, + "success": true + }, + { + "mutex_wait_ns": 3287200, + "serialization_ns": 83100, + "serialized_bytes": 1301, + "statement_ns": 3591200, + "success": true + }, + { + "mutex_wait_ns": 3526800, + "serialization_ns": 55800, + "serialized_bytes": 1081, + "statement_ns": 3311700, + "success": true + }, + { + "mutex_wait_ns": 2976900, + "serialization_ns": 36800, + "serialized_bytes": 612, + "statement_ns": 3238300, + "success": true + }, + { + "mutex_wait_ns": 3168100, + "serialization_ns": 62300, + "serialized_bytes": 1297, + "statement_ns": 3189900, + "success": true + }, + { + "mutex_wait_ns": 3171100, + "serialization_ns": 40700, + "serialized_bytes": 612, + "statement_ns": 3097200, + "success": true + }, + { + "mutex_wait_ns": 2754000, + "serialization_ns": 31400, + "serialized_bytes": 612, + "statement_ns": 3846300, + "success": true + }, + { + "mutex_wait_ns": 3793300, + "serialization_ns": 61100, + "serialized_bytes": 1038, + "statement_ns": 3674100, + "success": true + }, + { + "mutex_wait_ns": 3669400, + "serialization_ns": 34100, + "serialized_bytes": 612, + "statement_ns": 4424800, + "success": true + }, + { + "mutex_wait_ns": 4326500, + "serialization_ns": 70000, + "serialized_bytes": 1077, + "statement_ns": 4587800, + "success": true + }, + { + "mutex_wait_ns": 4529400, + "serialization_ns": 61600, + "serialized_bytes": 1038, + "statement_ns": 3887200, + "success": true + }, + { + "mutex_wait_ns": 3826100, + "serialization_ns": 66900, + "serialized_bytes": 1085, + "statement_ns": 3248700, + "success": true + }, + { + "mutex_wait_ns": 3150800, + "serialization_ns": 68500, + "serialized_bytes": 1077, + "statement_ns": 4122500, + "success": true + }, + { + "mutex_wait_ns": 4056600, + "serialization_ns": 77500, + "serialized_bytes": 1301, + "statement_ns": 3934700, + "success": true + }, + { + "mutex_wait_ns": 3560800, + "serialization_ns": 247300, + "serialized_bytes": 1085, + "statement_ns": 3286400, + "success": true + }, + { + "mutex_wait_ns": 2928900, + "serialization_ns": 30100, + "serialized_bytes": 612, + "statement_ns": 4526900, + "success": true + }, + { + "mutex_wait_ns": 4453900, + "serialization_ns": 63200, + "serialized_bytes": 1301, + "statement_ns": 3869100, + "success": true + }, + { + "mutex_wait_ns": 3947300, + "serialization_ns": 34100, + "serialized_bytes": 612, + "statement_ns": 4216200, + "success": true + }, + { + "mutex_wait_ns": 1540400, + "serialization_ns": 36200, + "serialized_bytes": 612, + "statement_ns": 3455900, + "success": true + }, + { + "mutex_wait_ns": 3407000, + "serialization_ns": 57100, + "serialized_bytes": 1038, + "statement_ns": 3498200, + "success": true + }, + { + "mutex_wait_ns": 3478600, + "serialization_ns": 42800, + "serialized_bytes": 612, + "statement_ns": 4063700, + "success": true + }, + { + "mutex_wait_ns": 3960500, + "serialization_ns": 72300, + "serialized_bytes": 1077, + "statement_ns": 4472400, + "success": true + }, + { + "mutex_wait_ns": 4418800, + "serialization_ns": 66400, + "serialized_bytes": 1038, + "statement_ns": 3634000, + "success": true + }, + { + "mutex_wait_ns": 3530400, + "serialization_ns": 108200, + "serialized_bytes": 1085, + "statement_ns": 3613200, + "success": true + }, + { + "mutex_wait_ns": 3517600, + "serialization_ns": 68300, + "serialized_bytes": 1077, + "statement_ns": 4093600, + "success": true + }, + { + "mutex_wait_ns": 4004700, + "serialization_ns": 76700, + "serialized_bytes": 1301, + "statement_ns": 4003800, + "success": true + }, + { + "mutex_wait_ns": 3939000, + "serialization_ns": 70200, + "serialized_bytes": 1085, + "statement_ns": 3780500, + "success": true + }, + { + "mutex_wait_ns": 3445400, + "serialization_ns": 36600, + "serialized_bytes": 612, + "statement_ns": 3445300, + "success": true + }, + { + "mutex_wait_ns": 3350400, + "serialization_ns": 76800, + "serialized_bytes": 1301, + "statement_ns": 3832000, + "success": true + }, + { + "mutex_wait_ns": 3810200, + "serialization_ns": 40100, + "serialized_bytes": 612, + "statement_ns": 3715100, + "success": true + }, + { + "mutex_wait_ns": 2506500, + "serialization_ns": 43600, + "serialized_bytes": 612, + "statement_ns": 20122800, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 45900, + "serialized_bytes": 612, + "statement_ns": 7635900, + "success": true + }, + { + "mutex_wait_ns": 27800800, + "serialization_ns": 96800, + "serialized_bytes": 1038, + "statement_ns": 3253600, + "success": true + }, + { + "mutex_wait_ns": 3197600, + "serialization_ns": 58900, + "serialized_bytes": 1038, + "statement_ns": 4133400, + "success": true + }, + { + "mutex_wait_ns": 4025900, + "serialization_ns": 69200, + "serialized_bytes": 1077, + "statement_ns": 3298600, + "success": true + }, + { + "mutex_wait_ns": 3220100, + "serialization_ns": 57500, + "serialized_bytes": 1077, + "statement_ns": 2831600, + "success": true + }, + { + "mutex_wait_ns": 2771100, + "serialization_ns": 57700, + "serialized_bytes": 1085, + "statement_ns": 2843800, + "success": true + }, + { + "mutex_wait_ns": 2785100, + "serialization_ns": 57100, + "serialized_bytes": 1085, + "statement_ns": 3147800, + "success": true + }, + { + "mutex_wait_ns": 3062800, + "serialization_ns": 65300, + "serialized_bytes": 1301, + "statement_ns": 3142000, + "success": true + }, + { + "mutex_wait_ns": 3071600, + "serialization_ns": 63700, + "serialized_bytes": 1301, + "statement_ns": 3322900, + "success": true + }, + { + "mutex_wait_ns": 3025600, + "serialization_ns": 30600, + "serialized_bytes": 612, + "statement_ns": 4962100, + "success": true + }, + { + "mutex_wait_ns": 4721300, + "serialization_ns": 29400, + "serialized_bytes": 612, + "statement_ns": 3458500, + "success": true + }, + { + "mutex_wait_ns": 3444500, + "serialization_ns": 35800, + "serialized_bytes": 612, + "statement_ns": 3085300, + "success": true + }, + { + "mutex_wait_ns": 3074800, + "serialization_ns": 34400, + "serialized_bytes": 612, + "statement_ns": 2729200, + "success": true + }, + { + "mutex_wait_ns": 2677100, + "serialization_ns": 51800, + "serialized_bytes": 1038, + "statement_ns": 2712400, + "success": true + }, + { + "mutex_wait_ns": 2666000, + "serialization_ns": 49800, + "serialized_bytes": 1038, + "statement_ns": 3002600, + "success": true + }, + { + "mutex_wait_ns": 2914200, + "serialization_ns": 54500, + "serialized_bytes": 1077, + "statement_ns": 2427700, + "success": true + }, + { + "mutex_wait_ns": 2352900, + "serialization_ns": 53800, + "serialized_bytes": 1077, + "statement_ns": 2984500, + "success": true + }, + { + "mutex_wait_ns": 2931700, + "serialization_ns": 54300, + "serialized_bytes": 1085, + "statement_ns": 2698000, + "success": true + }, + { + "mutex_wait_ns": 2656600, + "serialization_ns": 52000, + "serialized_bytes": 1085, + "statement_ns": 2972600, + "success": true + }, + { + "mutex_wait_ns": 2901500, + "serialization_ns": 59200, + "serialized_bytes": 1301, + "statement_ns": 4677500, + "success": true + }, + { + "mutex_wait_ns": 4612600, + "serialization_ns": 60500, + "serialized_bytes": 1301, + "statement_ns": 3807900, + "success": true + }, + { + "mutex_wait_ns": 3499500, + "serialization_ns": 30300, + "serialized_bytes": 612, + "statement_ns": 3414900, + "success": true + }, + { + "mutex_wait_ns": 3174700, + "serialization_ns": 30100, + "serialized_bytes": 612, + "statement_ns": 3424300, + "success": true + }, + { + "mutex_wait_ns": 3409600, + "serialization_ns": 34300, + "serialized_bytes": 612, + "statement_ns": 3662600, + "success": true + }, + { + "mutex_wait_ns": 3653300, + "serialization_ns": 33600, + "serialized_bytes": 612, + "statement_ns": 3676100, + "success": true + }, + { + "mutex_wait_ns": 3586900, + "serialization_ns": 79600, + "serialized_bytes": 1038, + "statement_ns": 3041400, + "success": true + }, + { + "mutex_wait_ns": 2993800, + "serialization_ns": 50400, + "serialized_bytes": 1038, + "statement_ns": 3342200, + "success": true + }, + { + "mutex_wait_ns": 3257800, + "serialization_ns": 54800, + "serialized_bytes": 1077, + "statement_ns": 2626800, + "success": true + }, + { + "mutex_wait_ns": 2561300, + "serialization_ns": 54300, + "serialized_bytes": 1077, + "statement_ns": 4623200, + "success": true + }, + { + "mutex_wait_ns": 4575000, + "serialization_ns": 56800, + "serialized_bytes": 1085, + "statement_ns": 3458200, + "success": true + }, + { + "mutex_wait_ns": 3392100, + "serialization_ns": 72600, + "serialized_bytes": 1085, + "statement_ns": 2952700, + "success": true + }, + { + "mutex_wait_ns": 2876900, + "serialization_ns": 62100, + "serialized_bytes": 1301, + "statement_ns": 2905400, + "success": true + }, + { + "mutex_wait_ns": 2812700, + "serialization_ns": 78000, + "serialized_bytes": 1301, + "statement_ns": 2633300, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 3820400, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=0", + "COMPILER=msvc-1944", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_W32", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "HTTP", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 648298800, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 102273300, + 102408500, + 102030200, + 499441600, + 496419600, + 499706500, + 499563600, + 499704400, + 499091000, + 500670300, + 500535300, + 500640700, + 530170200, + 528011300, + 639479500, + 640327900, + 639686900, + 640511800, + 639657000, + 640471500, + 639818900, + 640615700, + 639806100, + 640625800, + 638795700, + 638413900, + 639955200, + 639817800, + 639637000, + 640242500, + 639599000, + 644548500 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 95347200, + 418444000, + 102533000, + 376700, + 393200, + 492600 + ], + "failures": 0, + "in_window_samples": 3, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 95347200, + "end_ns": 106285000, + "in_window": true, + "scheduled_ns": null, + "start_ns": 10937800, + "success": true + }, + { + "elapsed_ns": 418444000, + "end_ns": 535230900, + "in_window": true, + "scheduled_ns": null, + "start_ns": 116786900, + "success": true + }, + { + "elapsed_ns": 102533000, + "end_ns": 648117100, + "in_window": true, + "scheduled_ns": null, + "start_ns": 545584100, + "success": true + }, + { + "elapsed_ns": 376700, + "end_ns": 658838400, + "in_window": false, + "scheduled_ns": null, + "start_ns": 658461700, + "success": true + }, + { + "elapsed_ns": 393200, + "end_ns": 669378600, + "in_window": false, + "scheduled_ns": null, + "start_ns": 668985400, + "success": true + }, + { + "elapsed_ns": 492600, + "end_ns": 680036400, + "in_window": false, + "scheduled_ns": null, + "start_ns": 679543800, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 92007200, + 191279900, + 332034000, + 4486500, + 1538000, + 5806500, + 13313900 + ], + "failures": 0, + "in_window_samples": 3, + "missed_periods": 62, + "samples": [ + { + "elapsed_ns": 92007200, + "end_ns": 106045800, + "in_window": true, + "scheduled_ns": 14038600, + "start_ns": 106045800, + "success": true + }, + { + "elapsed_ns": 191279900, + "end_ns": 305318500, + "in_window": true, + "scheduled_ns": 114038600, + "start_ns": 305318500, + "success": true + }, + { + "elapsed_ns": 332034000, + "end_ns": 646072600, + "in_window": true, + "scheduled_ns": 314038600, + "start_ns": 646072600, + "success": true + }, + { + "elapsed_ns": 4486500, + "end_ns": 658525100, + "in_window": false, + "scheduled_ns": 654038600, + "start_ns": 658525100, + "success": true + }, + { + "elapsed_ns": 1538000, + "end_ns": 665576600, + "in_window": false, + "scheduled_ns": 664038600, + "start_ns": 665576600, + "success": true + }, + { + "elapsed_ns": 5806500, + "end_ns": 679845100, + "in_window": false, + "scheduled_ns": 674038600, + "start_ns": 679845100, + "success": true + }, + { + "elapsed_ns": 13313900, + "end_ns": 697352500, + "in_window": false, + "scheduled_ns": 684038600, + "start_ns": 697352500, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 652365700, + "window_start_ns": 4066900 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 2, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 700, + "serialization_ns": 35400, + "serialized_bytes": 612, + "statement_ns": 8023900, + "success": true + }, + { + "mutex_wait_ns": 8040300, + "serialization_ns": 33100, + "serialized_bytes": 612, + "statement_ns": 3514100, + "success": true + }, + { + "mutex_wait_ns": 3486400, + "serialization_ns": 42800, + "serialized_bytes": 612, + "statement_ns": 2730600, + "success": true + }, + { + "mutex_wait_ns": 2713200, + "serialization_ns": 38000, + "serialized_bytes": 612, + "statement_ns": 3059900, + "success": true + }, + { + "mutex_wait_ns": 3002400, + "serialization_ns": 55500, + "serialized_bytes": 1038, + "statement_ns": 3139100, + "success": true + }, + { + "mutex_wait_ns": 3091000, + "serialization_ns": 50300, + "serialized_bytes": 1038, + "statement_ns": 3435000, + "success": true + }, + { + "mutex_wait_ns": 3345300, + "serialization_ns": 55400, + "serialized_bytes": 1077, + "statement_ns": 4631400, + "success": true + }, + { + "mutex_wait_ns": 4559300, + "serialization_ns": 53800, + "serialized_bytes": 1077, + "statement_ns": 3592700, + "success": true + }, + { + "mutex_wait_ns": 3537300, + "serialization_ns": 56900, + "serialized_bytes": 1085, + "statement_ns": 4399900, + "success": true + }, + { + "mutex_wait_ns": 4353300, + "serialization_ns": 58100, + "serialized_bytes": 1085, + "statement_ns": 2733400, + "success": true + }, + { + "mutex_wait_ns": 2652200, + "serialization_ns": 63900, + "serialized_bytes": 1301, + "statement_ns": 2684000, + "success": true + }, + { + "mutex_wait_ns": 2618900, + "serialization_ns": 62800, + "serialized_bytes": 1301, + "statement_ns": 18183900, + "success": true + }, + { + "mutex_wait_ns": 17741100, + "serialization_ns": 30300, + "serialized_bytes": 612, + "statement_ns": 3652000, + "success": true + }, + { + "mutex_wait_ns": 3156200, + "serialization_ns": 35500, + "serialized_bytes": 612, + "statement_ns": 3467100, + "success": true + }, + { + "mutex_wait_ns": 3448800, + "serialization_ns": 37900, + "serialized_bytes": 612, + "statement_ns": 2731400, + "success": true + }, + { + "mutex_wait_ns": 2717900, + "serialization_ns": 35600, + "serialized_bytes": 612, + "statement_ns": 2963200, + "success": true + }, + { + "mutex_wait_ns": 2904900, + "serialization_ns": 56800, + "serialized_bytes": 1038, + "statement_ns": 2820600, + "success": true + }, + { + "mutex_wait_ns": 2769800, + "serialization_ns": 52700, + "serialized_bytes": 1038, + "statement_ns": 2555600, + "success": true + }, + { + "mutex_wait_ns": 2453000, + "serialization_ns": 67300, + "serialized_bytes": 1077, + "statement_ns": 2798400, + "success": true + }, + { + "mutex_wait_ns": 2735400, + "serialization_ns": 52600, + "serialized_bytes": 1077, + "statement_ns": 3126600, + "success": true + }, + { + "mutex_wait_ns": 3062900, + "serialization_ns": 65200, + "serialized_bytes": 1085, + "statement_ns": 3022400, + "success": true + }, + { + "mutex_wait_ns": 2978900, + "serialization_ns": 53800, + "serialized_bytes": 1085, + "statement_ns": 4406500, + "success": true + }, + { + "mutex_wait_ns": 4310100, + "serialization_ns": 73500, + "serialized_bytes": 1301, + "statement_ns": 3907200, + "success": true + }, + { + "mutex_wait_ns": 3839700, + "serialization_ns": 61000, + "serialized_bytes": 1301, + "statement_ns": 3249600, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 37600, + "serialized_bytes": 612, + "statement_ns": 3812700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 34500, + "serialized_bytes": 612, + "statement_ns": 2663200, + "success": true + }, + { + "mutex_wait_ns": 6501200, + "serialization_ns": 30500, + "serialized_bytes": 612, + "statement_ns": 3046700, + "success": true + }, + { + "mutex_wait_ns": 2992800, + "serialization_ns": 52400, + "serialized_bytes": 1038, + "statement_ns": 3363100, + "success": true + }, + { + "mutex_wait_ns": 3345600, + "serialization_ns": 34500, + "serialized_bytes": 612, + "statement_ns": 3344500, + "success": true + }, + { + "mutex_wait_ns": 3260400, + "serialization_ns": 57900, + "serialized_bytes": 1077, + "statement_ns": 3897200, + "success": true + }, + { + "mutex_wait_ns": 3853100, + "serialization_ns": 49800, + "serialized_bytes": 1038, + "statement_ns": 2887300, + "success": true + }, + { + "mutex_wait_ns": 2834500, + "serialization_ns": 55700, + "serialized_bytes": 1085, + "statement_ns": 4841800, + "success": true + }, + { + "mutex_wait_ns": 4767200, + "serialization_ns": 51600, + "serialized_bytes": 1077, + "statement_ns": 2614900, + "success": true + }, + { + "mutex_wait_ns": 2548600, + "serialization_ns": 61700, + "serialized_bytes": 1301, + "statement_ns": 2829500, + "success": true + }, + { + "mutex_wait_ns": 2786700, + "serialization_ns": 53100, + "serialized_bytes": 1085, + "statement_ns": 2942400, + "success": true + }, + { + "mutex_wait_ns": 2616700, + "serialization_ns": 28500, + "serialized_bytes": 610, + "statement_ns": 3588700, + "success": true + }, + { + "mutex_wait_ns": 3511300, + "serialization_ns": 60200, + "serialized_bytes": 1301, + "statement_ns": 2837500, + "success": true + }, + { + "mutex_wait_ns": 2824400, + "serialization_ns": 31200, + "serialized_bytes": 610, + "statement_ns": 3116700, + "success": true + }, + { + "mutex_wait_ns": 2015800, + "serialization_ns": 28800, + "serialized_bytes": 612, + "statement_ns": 2939900, + "success": true + }, + { + "mutex_wait_ns": 2897000, + "serialization_ns": 48600, + "serialized_bytes": 1034, + "statement_ns": 2687300, + "success": true + }, + { + "mutex_wait_ns": 2678600, + "serialization_ns": 30800, + "serialized_bytes": 612, + "statement_ns": 2856300, + "success": true + }, + { + "mutex_wait_ns": 2766700, + "serialization_ns": 65200, + "serialized_bytes": 1073, + "statement_ns": 2599500, + "success": true + }, + { + "mutex_wait_ns": 2560700, + "serialization_ns": 48400, + "serialized_bytes": 1038, + "statement_ns": 3080000, + "success": true + }, + { + "mutex_wait_ns": 3020300, + "serialization_ns": 66300, + "serialized_bytes": 1081, + "statement_ns": 3282700, + "success": true + }, + { + "mutex_wait_ns": 3218800, + "serialization_ns": 50800, + "serialized_bytes": 1077, + "statement_ns": 3271600, + "success": true + }, + { + "mutex_wait_ns": 3186100, + "serialization_ns": 77900, + "serialized_bytes": 1297, + "statement_ns": 3668600, + "success": true + }, + { + "mutex_wait_ns": 3611600, + "serialization_ns": 66200, + "serialized_bytes": 1085, + "statement_ns": 3039100, + "success": true + }, + { + "mutex_wait_ns": 2679900, + "serialization_ns": 36000, + "serialized_bytes": 612, + "statement_ns": 3092200, + "success": true + }, + { + "mutex_wait_ns": 2942400, + "serialization_ns": 121000, + "serialized_bytes": 1301, + "statement_ns": 2812700, + "success": true + }, + { + "mutex_wait_ns": 2806000, + "serialization_ns": 37900, + "serialized_bytes": 612, + "statement_ns": 2958300, + "success": true + }, + { + "mutex_wait_ns": 2395800, + "serialization_ns": 36000, + "serialized_bytes": 612, + "statement_ns": 3579000, + "success": true + }, + { + "mutex_wait_ns": 3527300, + "serialization_ns": 60100, + "serialized_bytes": 1038, + "statement_ns": 3794700, + "success": true + }, + { + "mutex_wait_ns": 3779300, + "serialization_ns": 38700, + "serialized_bytes": 612, + "statement_ns": 2583400, + "success": true + }, + { + "mutex_wait_ns": 2510000, + "serialization_ns": 52700, + "serialized_bytes": 1077, + "statement_ns": 2512700, + "success": true + }, + { + "mutex_wait_ns": 2469900, + "serialization_ns": 48100, + "serialized_bytes": 1038, + "statement_ns": 2429900, + "success": true + }, + { + "mutex_wait_ns": 2385900, + "serialization_ns": 53500, + "serialized_bytes": 1085, + "statement_ns": 2690700, + "success": true + }, + { + "mutex_wait_ns": 2616900, + "serialization_ns": 51600, + "serialized_bytes": 1077, + "statement_ns": 2730100, + "success": true + }, + { + "mutex_wait_ns": 2664800, + "serialization_ns": 59300, + "serialized_bytes": 1301, + "statement_ns": 2809800, + "success": true + }, + { + "mutex_wait_ns": 2760700, + "serialization_ns": 53900, + "serialized_bytes": 1085, + "statement_ns": 2565400, + "success": true + }, + { + "mutex_wait_ns": 2249900, + "serialization_ns": 28800, + "serialized_bytes": 612, + "statement_ns": 4194000, + "success": true + }, + { + "mutex_wait_ns": 4134500, + "serialization_ns": 59700, + "serialized_bytes": 1301, + "statement_ns": 3037900, + "success": true + }, + { + "mutex_wait_ns": 3024900, + "serialization_ns": 35500, + "serialized_bytes": 612, + "statement_ns": 2781600, + "success": true + }, + { + "mutex_wait_ns": 2478200, + "serialization_ns": 29900, + "serialized_bytes": 612, + "statement_ns": 3406500, + "success": true + }, + { + "mutex_wait_ns": 3362300, + "serialization_ns": 48800, + "serialized_bytes": 1038, + "statement_ns": 3178100, + "success": true + }, + { + "mutex_wait_ns": 3159400, + "serialization_ns": 37800, + "serialized_bytes": 612, + "statement_ns": 3043500, + "success": true + }, + { + "mutex_wait_ns": 2973700, + "serialization_ns": 51000, + "serialized_bytes": 1077, + "statement_ns": 4710000, + "success": true + }, + { + "mutex_wait_ns": 4654300, + "serialization_ns": 54300, + "serialized_bytes": 1038, + "statement_ns": 4549800, + "success": true + }, + { + "mutex_wait_ns": 4503200, + "serialization_ns": 53400, + "serialized_bytes": 1085, + "statement_ns": 3285200, + "success": true + }, + { + "mutex_wait_ns": 3206200, + "serialization_ns": 53700, + "serialized_bytes": 1077, + "statement_ns": 2836500, + "success": true + }, + { + "mutex_wait_ns": 2769300, + "serialization_ns": 59800, + "serialized_bytes": 1301, + "statement_ns": 3030500, + "success": true + }, + { + "mutex_wait_ns": 2981900, + "serialization_ns": 55800, + "serialized_bytes": 1085, + "statement_ns": 2674400, + "success": true + }, + { + "mutex_wait_ns": 2310600, + "serialization_ns": 38700, + "serialized_bytes": 610, + "statement_ns": 3142300, + "success": true + }, + { + "mutex_wait_ns": 3028600, + "serialization_ns": 98400, + "serialized_bytes": 1301, + "statement_ns": 2788700, + "success": true + }, + { + "mutex_wait_ns": 2774200, + "serialization_ns": 39000, + "serialized_bytes": 610, + "statement_ns": 2917200, + "success": true + }, + { + "mutex_wait_ns": 2578100, + "serialization_ns": 34800, + "serialized_bytes": 612, + "statement_ns": 3292000, + "success": true + }, + { + "mutex_wait_ns": 3234900, + "serialization_ns": 60500, + "serialized_bytes": 1034, + "statement_ns": 2856300, + "success": true + }, + { + "mutex_wait_ns": 2844900, + "serialization_ns": 33500, + "serialized_bytes": 612, + "statement_ns": 2906500, + "success": true + }, + { + "mutex_wait_ns": 2808700, + "serialization_ns": 71600, + "serialized_bytes": 1073, + "statement_ns": 3303400, + "success": true + }, + { + "mutex_wait_ns": 3264600, + "serialization_ns": 49300, + "serialized_bytes": 1038, + "statement_ns": 3007600, + "success": true + }, + { + "mutex_wait_ns": 2947700, + "serialization_ns": 67000, + "serialized_bytes": 1081, + "statement_ns": 3703600, + "success": true + }, + { + "mutex_wait_ns": 3641600, + "serialization_ns": 51100, + "serialized_bytes": 1077, + "statement_ns": 3460800, + "success": true + }, + { + "mutex_wait_ns": 3369900, + "serialization_ns": 77000, + "serialized_bytes": 1297, + "statement_ns": 3880300, + "success": true + }, + { + "mutex_wait_ns": 3834200, + "serialization_ns": 53500, + "serialized_bytes": 1085, + "statement_ns": 3129800, + "success": true + }, + { + "mutex_wait_ns": 2768900, + "serialization_ns": 34700, + "serialized_bytes": 612, + "statement_ns": 4716400, + "success": true + }, + { + "mutex_wait_ns": 4658300, + "serialization_ns": 60900, + "serialized_bytes": 1301, + "statement_ns": 2955300, + "success": true + }, + { + "mutex_wait_ns": 2912600, + "serialization_ns": 64100, + "serialized_bytes": 612, + "statement_ns": 3159300, + "success": true + }, + { + "mutex_wait_ns": 2616300, + "serialization_ns": 36200, + "serialized_bytes": 610, + "statement_ns": 4209800, + "success": true + }, + { + "mutex_wait_ns": 4176700, + "serialization_ns": 48100, + "serialized_bytes": 1038, + "statement_ns": 3373700, + "success": true + }, + { + "mutex_wait_ns": 3360800, + "serialization_ns": 39200, + "serialized_bytes": 610, + "statement_ns": 3697400, + "success": true + }, + { + "mutex_wait_ns": 3622000, + "serialization_ns": 54300, + "serialized_bytes": 1077, + "statement_ns": 3178200, + "success": true + }, + { + "mutex_wait_ns": 3113300, + "serialization_ns": 61400, + "serialized_bytes": 1034, + "statement_ns": 3017700, + "success": true + }, + { + "mutex_wait_ns": 2968300, + "serialization_ns": 55000, + "serialized_bytes": 1085, + "statement_ns": 3038300, + "success": true + }, + { + "mutex_wait_ns": 2962300, + "serialization_ns": 54900, + "serialized_bytes": 1073, + "statement_ns": 3016700, + "success": true + }, + { + "mutex_wait_ns": 2947300, + "serialization_ns": 63100, + "serialized_bytes": 1301, + "statement_ns": 3450000, + "success": true + }, + { + "mutex_wait_ns": 3404200, + "serialization_ns": 56800, + "serialized_bytes": 1081, + "statement_ns": 3812700, + "success": true + }, + { + "mutex_wait_ns": 3489400, + "serialization_ns": 30300, + "serialized_bytes": 610, + "statement_ns": 4324100, + "success": true + }, + { + "mutex_wait_ns": 4251000, + "serialization_ns": 63300, + "serialized_bytes": 1297, + "statement_ns": 3330500, + "success": true + }, + { + "mutex_wait_ns": 3322300, + "serialization_ns": 34100, + "serialized_bytes": 610, + "statement_ns": 4588300, + "success": true + }, + { + "mutex_wait_ns": 4263800, + "serialization_ns": 28600, + "serialized_bytes": 610, + "statement_ns": 3120200, + "success": true + }, + { + "mutex_wait_ns": 3072200, + "serialization_ns": 50700, + "serialized_bytes": 1034, + "statement_ns": 2820700, + "success": true + }, + { + "mutex_wait_ns": 2853500, + "serialization_ns": 32300, + "serialized_bytes": 610, + "statement_ns": 3027700, + "success": true + }, + { + "mutex_wait_ns": 2993500, + "serialization_ns": 52600, + "serialized_bytes": 1073, + "statement_ns": 2629300, + "success": true + }, + { + "mutex_wait_ns": 2589000, + "serialization_ns": 48700, + "serialized_bytes": 1034, + "statement_ns": 5064900, + "success": true + }, + { + "mutex_wait_ns": 5020600, + "serialization_ns": 55300, + "serialized_bytes": 1081, + "statement_ns": 4428800, + "success": true + }, + { + "mutex_wait_ns": 4295200, + "serialization_ns": 57900, + "serialized_bytes": 1073, + "statement_ns": 3325800, + "success": true + }, + { + "mutex_wait_ns": 3253300, + "serialization_ns": 61400, + "serialized_bytes": 1297, + "statement_ns": 3295400, + "success": true + }, + { + "mutex_wait_ns": 3251400, + "serialization_ns": 55900, + "serialized_bytes": 1081, + "statement_ns": 3409600, + "success": true + }, + { + "mutex_wait_ns": 3091500, + "serialization_ns": 30200, + "serialized_bytes": 612, + "statement_ns": 3618300, + "success": true + }, + { + "mutex_wait_ns": 3527400, + "serialization_ns": 77500, + "serialized_bytes": 1297, + "statement_ns": 2904800, + "success": true + }, + { + "mutex_wait_ns": 2898100, + "serialization_ns": 32900, + "serialized_bytes": 612, + "statement_ns": 2769800, + "success": true + }, + { + "mutex_wait_ns": 2374300, + "serialization_ns": 35800, + "serialized_bytes": 610, + "statement_ns": 3508700, + "success": true + }, + { + "mutex_wait_ns": 3464200, + "serialization_ns": 50000, + "serialized_bytes": 1038, + "statement_ns": 3174600, + "success": true + }, + { + "mutex_wait_ns": 3078000, + "serialization_ns": 113600, + "serialized_bytes": 610, + "statement_ns": 2924700, + "success": true + }, + { + "mutex_wait_ns": 2844700, + "serialization_ns": 52700, + "serialized_bytes": 1077, + "statement_ns": 2661200, + "success": true + }, + { + "mutex_wait_ns": 2603700, + "serialization_ns": 60300, + "serialized_bytes": 1034, + "statement_ns": 3628200, + "success": true + }, + { + "mutex_wait_ns": 3583200, + "serialization_ns": 53300, + "serialized_bytes": 1085, + "statement_ns": 3821700, + "success": true + }, + { + "mutex_wait_ns": 3735300, + "serialization_ns": 65400, + "serialized_bytes": 1073, + "statement_ns": 3033100, + "success": true + }, + { + "mutex_wait_ns": 2972000, + "serialization_ns": 61200, + "serialized_bytes": 1301, + "statement_ns": 4844600, + "success": true + }, + { + "mutex_wait_ns": 4786000, + "serialization_ns": 64000, + "serialized_bytes": 1081, + "statement_ns": 2882700, + "success": true + }, + { + "mutex_wait_ns": 2573800, + "serialization_ns": 29500, + "serialized_bytes": 610, + "statement_ns": 3279400, + "success": true + }, + { + "mutex_wait_ns": 3214400, + "serialization_ns": 60000, + "serialized_bytes": 1297, + "statement_ns": 2964200, + "success": true + }, + { + "mutex_wait_ns": 2954600, + "serialization_ns": 32800, + "serialized_bytes": 610, + "statement_ns": 3026300, + "success": true + }, + { + "mutex_wait_ns": 2568600, + "serialization_ns": 43900, + "serialized_bytes": 610, + "statement_ns": 3680300, + "success": true + }, + { + "mutex_wait_ns": 3651100, + "serialization_ns": 51100, + "serialized_bytes": 1034, + "statement_ns": 2655500, + "success": true + }, + { + "mutex_wait_ns": 2638700, + "serialization_ns": 35000, + "serialized_bytes": 610, + "statement_ns": 2394700, + "success": true + }, + { + "mutex_wait_ns": 2312200, + "serialization_ns": 56300, + "serialized_bytes": 1073, + "statement_ns": 2515200, + "success": true + }, + { + "mutex_wait_ns": 2476300, + "serialization_ns": 48300, + "serialized_bytes": 1034, + "statement_ns": 2718500, + "success": true + }, + { + "mutex_wait_ns": 2675600, + "serialization_ns": 53400, + "serialized_bytes": 1081, + "statement_ns": 2642700, + "success": true + }, + { + "mutex_wait_ns": 2573900, + "serialization_ns": 50500, + "serialized_bytes": 1073, + "statement_ns": 2587800, + "success": true + }, + { + "mutex_wait_ns": 2520700, + "serialization_ns": 60200, + "serialized_bytes": 1297, + "statement_ns": 3067400, + "success": true + }, + { + "mutex_wait_ns": 3007000, + "serialization_ns": 50900, + "serialized_bytes": 1081, + "statement_ns": 3204700, + "success": true + }, + { + "mutex_wait_ns": 2893400, + "serialization_ns": 27900, + "serialized_bytes": 612, + "statement_ns": 4976100, + "success": true + }, + { + "mutex_wait_ns": 4914400, + "serialization_ns": 59000, + "serialized_bytes": 1297, + "statement_ns": 3476800, + "success": true + }, + { + "mutex_wait_ns": 3463200, + "serialization_ns": 32100, + "serialized_bytes": 612, + "statement_ns": 2321900, + "success": true + }, + { + "mutex_wait_ns": 1997400, + "serialization_ns": 30100, + "serialized_bytes": 612, + "statement_ns": 2959300, + "success": true + }, + { + "mutex_wait_ns": 2915900, + "serialization_ns": 48200, + "serialized_bytes": 1038, + "statement_ns": 2533500, + "success": true + }, + { + "mutex_wait_ns": 2524700, + "serialization_ns": 33600, + "serialized_bytes": 612, + "statement_ns": 2822600, + "success": true + }, + { + "mutex_wait_ns": 2755400, + "serialization_ns": 51300, + "serialized_bytes": 1077, + "statement_ns": 2814800, + "success": true + }, + { + "mutex_wait_ns": 2740100, + "serialization_ns": 77100, + "serialized_bytes": 1038, + "statement_ns": 3106100, + "success": true + }, + { + "mutex_wait_ns": 3059500, + "serialization_ns": 54200, + "serialized_bytes": 1085, + "statement_ns": 3968600, + "success": true + }, + { + "mutex_wait_ns": 3897000, + "serialization_ns": 52600, + "serialized_bytes": 1077, + "statement_ns": 3501900, + "success": true + }, + { + "mutex_wait_ns": 3416700, + "serialization_ns": 75000, + "serialized_bytes": 1301, + "statement_ns": 3362600, + "success": true + }, + { + "mutex_wait_ns": 3319800, + "serialization_ns": 55000, + "serialized_bytes": 1085, + "statement_ns": 2836600, + "success": true + }, + { + "mutex_wait_ns": 2471400, + "serialization_ns": 35200, + "serialized_bytes": 612, + "statement_ns": 3313500, + "success": true + }, + { + "mutex_wait_ns": 3235500, + "serialization_ns": 75900, + "serialized_bytes": 1301, + "statement_ns": 4344300, + "success": true + }, + { + "mutex_wait_ns": 4337300, + "serialization_ns": 40100, + "serialized_bytes": 612, + "statement_ns": 3453300, + "success": true + }, + { + "mutex_wait_ns": 1683400, + "serialization_ns": 37000, + "serialized_bytes": 612, + "statement_ns": 2995900, + "success": true + }, + { + "mutex_wait_ns": 2940300, + "serialization_ns": 60700, + "serialized_bytes": 1038, + "statement_ns": 2778100, + "success": true + }, + { + "mutex_wait_ns": 2765300, + "serialization_ns": 38500, + "serialized_bytes": 612, + "statement_ns": 2938800, + "success": true + }, + { + "mutex_wait_ns": 2815700, + "serialization_ns": 67400, + "serialized_bytes": 1077, + "statement_ns": 3121900, + "success": true + }, + { + "mutex_wait_ns": 3079200, + "serialization_ns": 48000, + "serialized_bytes": 1038, + "statement_ns": 3072400, + "success": true + }, + { + "mutex_wait_ns": 3025800, + "serialization_ns": 54100, + "serialized_bytes": 1085, + "statement_ns": 3991700, + "success": true + }, + { + "mutex_wait_ns": 3910700, + "serialization_ns": 55200, + "serialized_bytes": 1077, + "statement_ns": 3845100, + "success": true + }, + { + "mutex_wait_ns": 3772100, + "serialization_ns": 60800, + "serialized_bytes": 1301, + "statement_ns": 3607600, + "success": true + }, + { + "mutex_wait_ns": 3557600, + "serialization_ns": 55000, + "serialized_bytes": 1085, + "statement_ns": 2992000, + "success": true + }, + { + "mutex_wait_ns": 2174300, + "serialization_ns": 28800, + "serialized_bytes": 612, + "statement_ns": 3067000, + "success": true + }, + { + "mutex_wait_ns": 2915800, + "serialization_ns": 114800, + "serialized_bytes": 1301, + "statement_ns": 2817500, + "success": true + }, + { + "mutex_wait_ns": 2808600, + "serialization_ns": 34700, + "serialized_bytes": 612, + "statement_ns": 2647600, + "success": true + }, + { + "mutex_wait_ns": 2309600, + "serialization_ns": 27800, + "serialized_bytes": 612, + "statement_ns": 3449800, + "success": true + }, + { + "mutex_wait_ns": 3406200, + "serialization_ns": 49600, + "serialized_bytes": 1038, + "statement_ns": 3452700, + "success": true + }, + { + "mutex_wait_ns": 3441900, + "serialization_ns": 31500, + "serialized_bytes": 612, + "statement_ns": 3155600, + "success": true + }, + { + "mutex_wait_ns": 3075000, + "serialization_ns": 56000, + "serialized_bytes": 1077, + "statement_ns": 2597800, + "success": true + }, + { + "mutex_wait_ns": 2554600, + "serialization_ns": 48900, + "serialized_bytes": 1038, + "statement_ns": 2601700, + "success": true + }, + { + "mutex_wait_ns": 2556700, + "serialization_ns": 53700, + "serialized_bytes": 1085, + "statement_ns": 2533300, + "success": true + }, + { + "mutex_wait_ns": 2454100, + "serialization_ns": 55500, + "serialized_bytes": 1077, + "statement_ns": 2843500, + "success": true + }, + { + "mutex_wait_ns": 2790400, + "serialization_ns": 59700, + "serialized_bytes": 1301, + "statement_ns": 3426300, + "success": true + }, + { + "mutex_wait_ns": 3404400, + "serialization_ns": 51900, + "serialized_bytes": 1085, + "statement_ns": 2341700, + "success": true + }, + { + "mutex_wait_ns": 1983400, + "serialization_ns": 36000, + "serialized_bytes": 610, + "statement_ns": 2946300, + "success": true + }, + { + "mutex_wait_ns": 2884300, + "serialization_ns": 60200, + "serialized_bytes": 1301, + "statement_ns": 3139400, + "success": true + }, + { + "mutex_wait_ns": 3122700, + "serialization_ns": 38600, + "serialized_bytes": 610, + "statement_ns": 3319200, + "success": true + }, + { + "mutex_wait_ns": 3021300, + "serialization_ns": 27700, + "serialized_bytes": 610, + "statement_ns": 4010900, + "success": true + }, + { + "mutex_wait_ns": 3955000, + "serialization_ns": 60000, + "serialized_bytes": 1034, + "statement_ns": 2963400, + "success": true + }, + { + "mutex_wait_ns": 2954800, + "serialization_ns": 32200, + "serialized_bytes": 610, + "statement_ns": 5872600, + "success": true + }, + { + "mutex_wait_ns": 5776700, + "serialization_ns": 67200, + "serialized_bytes": 1073, + "statement_ns": 2770600, + "success": true + }, + { + "mutex_wait_ns": 2722900, + "serialization_ns": 50700, + "serialized_bytes": 1034, + "statement_ns": 2775900, + "success": true + }, + { + "mutex_wait_ns": 2707900, + "serialization_ns": 67700, + "serialized_bytes": 1081, + "statement_ns": 2973600, + "success": true + }, + { + "mutex_wait_ns": 2899500, + "serialization_ns": 53300, + "serialized_bytes": 1073, + "statement_ns": 2768500, + "success": true + }, + { + "mutex_wait_ns": 2673500, + "serialization_ns": 78900, + "serialized_bytes": 1297, + "statement_ns": 2671600, + "success": true + }, + { + "mutex_wait_ns": 2622300, + "serialization_ns": 54000, + "serialized_bytes": 1081, + "statement_ns": 2406500, + "success": true + }, + { + "mutex_wait_ns": 2092000, + "serialization_ns": 28300, + "serialized_bytes": 612, + "statement_ns": 3092400, + "success": true + }, + { + "mutex_wait_ns": 3032400, + "serialization_ns": 59600, + "serialized_bytes": 1297, + "statement_ns": 2982100, + "success": true + }, + { + "mutex_wait_ns": 2967900, + "serialization_ns": 33900, + "serialized_bytes": 612, + "statement_ns": 2861400, + "success": true + }, + { + "mutex_wait_ns": 2525300, + "serialization_ns": 37900, + "serialized_bytes": 612, + "statement_ns": 3521800, + "success": true + }, + { + "mutex_wait_ns": 3478900, + "serialization_ns": 48400, + "serialized_bytes": 1038, + "statement_ns": 3384800, + "success": true + }, + { + "mutex_wait_ns": 3382800, + "serialization_ns": 33500, + "serialized_bytes": 612, + "statement_ns": 2975900, + "success": true + }, + { + "mutex_wait_ns": 2914000, + "serialization_ns": 52000, + "serialized_bytes": 1077, + "statement_ns": 3867800, + "success": true + }, + { + "mutex_wait_ns": 3825000, + "serialization_ns": 48500, + "serialized_bytes": 1038, + "statement_ns": 2413600, + "success": true + }, + { + "mutex_wait_ns": 2353200, + "serialization_ns": 57900, + "serialized_bytes": 1085, + "statement_ns": 2659000, + "success": true + }, + { + "mutex_wait_ns": 2575600, + "serialization_ns": 57300, + "serialized_bytes": 1077, + "statement_ns": 2540000, + "success": true + }, + { + "mutex_wait_ns": 2467700, + "serialization_ns": 64600, + "serialized_bytes": 1301, + "statement_ns": 3423100, + "success": true + }, + { + "mutex_wait_ns": 3376700, + "serialization_ns": 53400, + "serialized_bytes": 1085, + "statement_ns": 2393600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 59600, + "serialized_bytes": 1301, + "statement_ns": 3740600, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 4064500, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=0", + "COMPILER=msvc-1944", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_W32", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "HTTP", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 717347500, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 166304100, + 166604700, + 468330300, + 543157400, + 578208400, + 579972100, + 578504100, + 579937200, + 578796500, + 580330600, + 579129800, + 579063500, + 579133500, + 579212200, + 656547600, + 697555800, + 698489100, + 699366700, + 697500400, + 699368300, + 698058300, + 697610500, + 697650900, + 697716300, + 697754200, + 698450900, + 698164200, + 698145500, + 698232800, + 698258600, + 698319900, + 713030600 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 46949100, + 12218300, + 28125800, + 453380800, + 110063400, + 360800, + 366700, + 400500 + ], + "failures": 0, + "in_window_samples": 6, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 46949100, + "end_ns": 68368900, + "in_window": true, + "scheduled_ns": null, + "start_ns": 21419800, + "success": true + }, + { + "elapsed_ns": 12218300, + "end_ns": 90751500, + "in_window": true, + "scheduled_ns": null, + "start_ns": 78533200, + "success": true + }, + { + "elapsed_ns": 28125800, + "end_ns": 129389500, + "in_window": true, + "scheduled_ns": null, + "start_ns": 101263700, + "success": true + }, + { + "elapsed_ns": 453380800, + "end_ns": 592864600, + "in_window": true, + "scheduled_ns": null, + "start_ns": 139483800, + "success": true + }, + { + "elapsed_ns": 110063400, + "end_ns": 713031200, + "in_window": true, + "scheduled_ns": null, + "start_ns": 602967800, + "success": true + }, + { + "elapsed_ns": 360800, + "end_ns": 723842200, + "in_window": true, + "scheduled_ns": null, + "start_ns": 723481400, + "success": true + }, + { + "elapsed_ns": 366700, + "end_ns": 734427800, + "in_window": false, + "scheduled_ns": null, + "start_ns": 734061100, + "success": true + }, + { + "elapsed_ns": 400500, + "end_ns": 745010800, + "in_window": false, + "scheduled_ns": null, + "start_ns": 744610300, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 1728800, + 34955500, + 14984600, + 36791900, + 259366500, + 318998800, + 2615300, + 1237300, + 2967300, + 3558100, + 3442300, + 9764300 + ], + "failures": 0, + "in_window_samples": 8, + "missed_periods": 63, + "samples": [ + { + "elapsed_ns": 1728800, + "end_ns": 23021000, + "in_window": true, + "scheduled_ns": 21292200, + "start_ns": 23021000, + "success": true + }, + { + "elapsed_ns": 34955500, + "end_ns": 66247700, + "in_window": true, + "scheduled_ns": 31292200, + "start_ns": 66247700, + "success": true + }, + { + "elapsed_ns": 14984600, + "end_ns": 86276800, + "in_window": true, + "scheduled_ns": 71292200, + "start_ns": 86276800, + "success": true + }, + { + "elapsed_ns": 36791900, + "end_ns": 128084100, + "in_window": true, + "scheduled_ns": 91292200, + "start_ns": 128084100, + "success": true + }, + { + "elapsed_ns": 259366500, + "end_ns": 390658700, + "in_window": true, + "scheduled_ns": 131292200, + "start_ns": 390658700, + "success": true + }, + { + "elapsed_ns": 318998800, + "end_ns": 710291000, + "in_window": true, + "scheduled_ns": 391292200, + "start_ns": 710291000, + "success": true + }, + { + "elapsed_ns": 2615300, + "end_ns": 713907500, + "in_window": true, + "scheduled_ns": 711292200, + "start_ns": 713907500, + "success": true + }, + { + "elapsed_ns": 1237300, + "end_ns": 722529500, + "in_window": true, + "scheduled_ns": 721292200, + "start_ns": 722529500, + "success": true + }, + { + "elapsed_ns": 2967300, + "end_ns": 734259500, + "in_window": false, + "scheduled_ns": 731292200, + "start_ns": 734259500, + "success": true + }, + { + "elapsed_ns": 3558100, + "end_ns": 744850300, + "in_window": false, + "scheduled_ns": 741292200, + "start_ns": 744850300, + "success": true + }, + { + "elapsed_ns": 3442300, + "end_ns": 754734500, + "in_window": false, + "scheduled_ns": 751292200, + "start_ns": 754734500, + "success": true + }, + { + "elapsed_ns": 9764300, + "end_ns": 771056500, + "in_window": false, + "scheduled_ns": 761292200, + "start_ns": 771056500, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 728675400, + "window_start_ns": 11327900 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 0, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 1000, + "serialization_ns": 35000, + "serialized_bytes": 613, + "statement_ns": 3262500, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 35500, + "serialized_bytes": 613, + "statement_ns": 3701300, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 50900, + "serialized_bytes": 1040, + "statement_ns": 2654800, + "success": true + }, + { + "mutex_wait_ns": 2601900, + "serialization_ns": 33000, + "serialized_bytes": 613, + "statement_ns": 3062700, + "success": true + }, + { + "mutex_wait_ns": 3006600, + "serialization_ns": 57200, + "serialized_bytes": 1079, + "statement_ns": 2509900, + "success": true + }, + { + "mutex_wait_ns": 2500800, + "serialization_ns": 34100, + "serialized_bytes": 613, + "statement_ns": 3031400, + "success": true + }, + { + "mutex_wait_ns": 2984200, + "serialization_ns": 56800, + "serialized_bytes": 1087, + "statement_ns": 2428400, + "success": true + }, + { + "mutex_wait_ns": 2385000, + "serialization_ns": 49800, + "serialized_bytes": 1040, + "statement_ns": 2960900, + "success": true + }, + { + "mutex_wait_ns": 2893700, + "serialization_ns": 61500, + "serialized_bytes": 1303, + "statement_ns": 2938400, + "success": true + }, + { + "mutex_wait_ns": 2866000, + "serialization_ns": 54000, + "serialized_bytes": 1079, + "statement_ns": 4242200, + "success": true + }, + { + "mutex_wait_ns": 920800, + "serialization_ns": 31100, + "serialized_bytes": 613, + "statement_ns": 2982900, + "success": true + }, + { + "mutex_wait_ns": 2950100, + "serialization_ns": 54700, + "serialized_bytes": 1087, + "statement_ns": 2744500, + "success": true + }, + { + "mutex_wait_ns": 2746200, + "serialization_ns": 33300, + "serialized_bytes": 613, + "statement_ns": 2684200, + "success": true + }, + { + "mutex_wait_ns": 2606500, + "serialization_ns": 66600, + "serialized_bytes": 1303, + "statement_ns": 2331000, + "success": true + }, + { + "mutex_wait_ns": 2297100, + "serialization_ns": 48700, + "serialized_bytes": 1040, + "statement_ns": 2577200, + "success": true + }, + { + "mutex_wait_ns": 1997400, + "serialization_ns": 112400, + "serialized_bytes": 613, + "statement_ns": 4204700, + "success": true + }, + { + "mutex_wait_ns": 4137700, + "serialization_ns": 53200, + "serialized_bytes": 1079, + "statement_ns": 3880700, + "success": true + }, + { + "mutex_wait_ns": 3871300, + "serialization_ns": 33000, + "serialized_bytes": 613, + "statement_ns": 2854600, + "success": true + }, + { + "mutex_wait_ns": 2811500, + "serialization_ns": 53200, + "serialized_bytes": 1087, + "statement_ns": 2907100, + "success": true + }, + { + "mutex_wait_ns": 2865000, + "serialization_ns": 48900, + "serialized_bytes": 1040, + "statement_ns": 3232200, + "success": true + }, + { + "mutex_wait_ns": 3064500, + "serialization_ns": 102300, + "serialized_bytes": 1303, + "statement_ns": 3509800, + "success": true + }, + { + "mutex_wait_ns": 3430100, + "serialization_ns": 55000, + "serialized_bytes": 1079, + "statement_ns": 2720300, + "success": true + }, + { + "mutex_wait_ns": 2163200, + "serialization_ns": 31900, + "serialized_bytes": 611, + "statement_ns": 2883200, + "success": true + }, + { + "mutex_wait_ns": 2838600, + "serialization_ns": 55900, + "serialized_bytes": 1087, + "statement_ns": 2533800, + "success": true + }, + { + "mutex_wait_ns": 2527200, + "serialization_ns": 33400, + "serialized_bytes": 611, + "statement_ns": 2606400, + "success": true + }, + { + "mutex_wait_ns": 2520700, + "serialization_ns": 69600, + "serialized_bytes": 1303, + "statement_ns": 2731300, + "success": true + }, + { + "mutex_wait_ns": 2681700, + "serialization_ns": 50300, + "serialized_bytes": 1036, + "statement_ns": 2752900, + "success": true + }, + { + "mutex_wait_ns": 1728400, + "serialization_ns": 29100, + "serialized_bytes": 613, + "statement_ns": 3071900, + "success": true + }, + { + "mutex_wait_ns": 3006100, + "serialization_ns": 52600, + "serialized_bytes": 1075, + "statement_ns": 5548800, + "success": true + }, + { + "mutex_wait_ns": 5543600, + "serialization_ns": 34400, + "serialized_bytes": 613, + "statement_ns": 3502700, + "success": true + }, + { + "mutex_wait_ns": 3457600, + "serialization_ns": 58800, + "serialized_bytes": 1083, + "statement_ns": 3427600, + "success": true + }, + { + "mutex_wait_ns": 3384500, + "serialization_ns": 49200, + "serialized_bytes": 1040, + "statement_ns": 3507800, + "success": true + }, + { + "mutex_wait_ns": 3433800, + "serialization_ns": 61100, + "serialized_bytes": 1299, + "statement_ns": 2992300, + "success": true + }, + { + "mutex_wait_ns": 2922000, + "serialization_ns": 53100, + "serialized_bytes": 1079, + "statement_ns": 2659300, + "success": true + }, + { + "mutex_wait_ns": 2129700, + "serialization_ns": 29100, + "serialized_bytes": 611, + "statement_ns": 2922900, + "success": true + }, + { + "mutex_wait_ns": 2882300, + "serialization_ns": 52800, + "serialized_bytes": 1087, + "statement_ns": 3210000, + "success": true + }, + { + "mutex_wait_ns": 3199700, + "serialization_ns": 33400, + "serialized_bytes": 611, + "statement_ns": 4195200, + "success": true + }, + { + "mutex_wait_ns": 4121900, + "serialization_ns": 63000, + "serialized_bytes": 1303, + "statement_ns": 2646100, + "success": true + }, + { + "mutex_wait_ns": 2601900, + "serialization_ns": 48100, + "serialized_bytes": 1036, + "statement_ns": 2703900, + "success": true + }, + { + "mutex_wait_ns": 2184600, + "serialization_ns": 28100, + "serialized_bytes": 611, + "statement_ns": 3156300, + "success": true + }, + { + "mutex_wait_ns": 3088200, + "serialization_ns": 51600, + "serialized_bytes": 1075, + "statement_ns": 5886200, + "success": true + }, + { + "mutex_wait_ns": 5881300, + "serialization_ns": 31900, + "serialized_bytes": 611, + "statement_ns": 2767400, + "success": true + }, + { + "mutex_wait_ns": 2726600, + "serialization_ns": 54200, + "serialized_bytes": 1083, + "statement_ns": 2670000, + "success": true + }, + { + "mutex_wait_ns": 2626700, + "serialization_ns": 48700, + "serialized_bytes": 1036, + "statement_ns": 3302400, + "success": true + }, + { + "mutex_wait_ns": 3230400, + "serialization_ns": 61500, + "serialized_bytes": 1299, + "statement_ns": 3048400, + "success": true + }, + { + "mutex_wait_ns": 2982200, + "serialization_ns": 51300, + "serialized_bytes": 1075, + "statement_ns": 3236300, + "success": true + }, + { + "mutex_wait_ns": 2713500, + "serialization_ns": 28800, + "serialized_bytes": 613, + "statement_ns": 2832000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 33000, + "serialized_bytes": 613, + "statement_ns": 5876700, + "success": true + }, + { + "mutex_wait_ns": 8726900, + "serialization_ns": 52800, + "serialized_bytes": 1083, + "statement_ns": 3187300, + "success": true + }, + { + "mutex_wait_ns": 3150600, + "serialization_ns": 50000, + "serialized_bytes": 1040, + "statement_ns": 2657800, + "success": true + }, + { + "mutex_wait_ns": 2582100, + "serialization_ns": 62100, + "serialized_bytes": 1299, + "statement_ns": 3081800, + "success": true + }, + { + "mutex_wait_ns": 3014900, + "serialization_ns": 52100, + "serialized_bytes": 1079, + "statement_ns": 2671000, + "success": true + }, + { + "mutex_wait_ns": 2155600, + "serialization_ns": 28400, + "serialized_bytes": 613, + "statement_ns": 8088400, + "success": true + }, + { + "mutex_wait_ns": 8047600, + "serialization_ns": 53000, + "serialized_bytes": 1087, + "statement_ns": 2866400, + "success": true + }, + { + "mutex_wait_ns": 2848300, + "serialization_ns": 41600, + "serialized_bytes": 613, + "statement_ns": 2755600, + "success": true + }, + { + "mutex_wait_ns": 2687000, + "serialization_ns": 61500, + "serialized_bytes": 1303, + "statement_ns": 3432000, + "success": true + }, + { + "mutex_wait_ns": 3376800, + "serialization_ns": 60500, + "serialized_bytes": 1040, + "statement_ns": 3062000, + "success": true + }, + { + "mutex_wait_ns": 2536300, + "serialization_ns": 30100, + "serialized_bytes": 611, + "statement_ns": 2830100, + "success": true + }, + { + "mutex_wait_ns": 2743200, + "serialization_ns": 64200, + "serialized_bytes": 1079, + "statement_ns": 3074300, + "success": true + }, + { + "mutex_wait_ns": 3064600, + "serialization_ns": 34200, + "serialized_bytes": 611, + "statement_ns": 3647200, + "success": true + }, + { + "mutex_wait_ns": 3587100, + "serialization_ns": 66100, + "serialized_bytes": 1087, + "statement_ns": 2901200, + "success": true + }, + { + "mutex_wait_ns": 2857800, + "serialization_ns": 48700, + "serialized_bytes": 1036, + "statement_ns": 3176200, + "success": true + }, + { + "mutex_wait_ns": 3094700, + "serialization_ns": 65400, + "serialized_bytes": 1303, + "statement_ns": 5544000, + "success": true + }, + { + "mutex_wait_ns": 5478200, + "serialization_ns": 52000, + "serialized_bytes": 1075, + "statement_ns": 2819600, + "success": true + }, + { + "mutex_wait_ns": 2290300, + "serialization_ns": 29300, + "serialized_bytes": 613, + "statement_ns": 3393000, + "success": true + }, + { + "mutex_wait_ns": 3353700, + "serialization_ns": 55100, + "serialized_bytes": 1083, + "statement_ns": 2720600, + "success": true + }, + { + "mutex_wait_ns": 2697100, + "serialization_ns": 39600, + "serialized_bytes": 613, + "statement_ns": 3630800, + "success": true + }, + { + "mutex_wait_ns": 3568400, + "serialization_ns": 61000, + "serialized_bytes": 1299, + "statement_ns": 4194900, + "success": true + }, + { + "mutex_wait_ns": 4146800, + "serialization_ns": 61100, + "serialized_bytes": 1040, + "statement_ns": 2688900, + "success": true + }, + { + "mutex_wait_ns": 2144200, + "serialization_ns": 31000, + "serialized_bytes": 611, + "statement_ns": 2768600, + "success": true + }, + { + "mutex_wait_ns": 2675400, + "serialization_ns": 70300, + "serialized_bytes": 1079, + "statement_ns": 2674600, + "success": true + }, + { + "mutex_wait_ns": 2665200, + "serialization_ns": 34900, + "serialized_bytes": 611, + "statement_ns": 4483400, + "success": true + }, + { + "mutex_wait_ns": 4419400, + "serialization_ns": 69900, + "serialized_bytes": 1087, + "statement_ns": 4119100, + "success": true + }, + { + "mutex_wait_ns": 4071100, + "serialization_ns": 51400, + "serialized_bytes": 1036, + "statement_ns": 2494000, + "success": true + }, + { + "mutex_wait_ns": 2413600, + "serialization_ns": 62100, + "serialized_bytes": 1303, + "statement_ns": 2639600, + "success": true + }, + { + "mutex_wait_ns": 2565800, + "serialization_ns": 52900, + "serialized_bytes": 1075, + "statement_ns": 2621000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 54300, + "serialized_bytes": 1083, + "statement_ns": 2503700, + "success": true + }, + { + "mutex_wait_ns": 2168200, + "serialization_ns": 29800, + "serialized_bytes": 613, + "statement_ns": 3174100, + "success": true + }, + { + "mutex_wait_ns": 3110400, + "serialization_ns": 60500, + "serialized_bytes": 1299, + "statement_ns": 3717700, + "success": true + }, + { + "mutex_wait_ns": 3711000, + "serialization_ns": 31800, + "serialized_bytes": 613, + "statement_ns": 2580100, + "success": true + }, + { + "mutex_wait_ns": 2086300, + "serialization_ns": 29400, + "serialized_bytes": 613, + "statement_ns": 2974700, + "success": true + }, + { + "mutex_wait_ns": 2928900, + "serialization_ns": 50000, + "serialized_bytes": 1040, + "statement_ns": 2841000, + "success": true + }, + { + "mutex_wait_ns": 2834000, + "serialization_ns": 32400, + "serialized_bytes": 613, + "statement_ns": 2614300, + "success": true + }, + { + "mutex_wait_ns": 2517200, + "serialization_ns": 69800, + "serialized_bytes": 1079, + "statement_ns": 4497800, + "success": true + }, + { + "mutex_wait_ns": 4462500, + "serialization_ns": 49000, + "serialized_bytes": 1040, + "statement_ns": 3225400, + "success": true + }, + { + "mutex_wait_ns": 3164000, + "serialization_ns": 69600, + "serialized_bytes": 1087, + "statement_ns": 3987400, + "success": true + }, + { + "mutex_wait_ns": 3917600, + "serialization_ns": 53700, + "serialized_bytes": 1079, + "statement_ns": 3629200, + "success": true + }, + { + "mutex_wait_ns": 3532300, + "serialization_ns": 80800, + "serialized_bytes": 1303, + "statement_ns": 2687200, + "success": true + }, + { + "mutex_wait_ns": 2633200, + "serialization_ns": 58400, + "serialized_bytes": 1087, + "statement_ns": 5047500, + "success": true + }, + { + "mutex_wait_ns": 2582800, + "serialization_ns": 37700, + "serialized_bytes": 611, + "statement_ns": 2908900, + "success": true + }, + { + "mutex_wait_ns": 2840900, + "serialization_ns": 62400, + "serialized_bytes": 1303, + "statement_ns": 2962800, + "success": true + }, + { + "mutex_wait_ns": 2955300, + "serialization_ns": 34700, + "serialized_bytes": 611, + "statement_ns": 2938700, + "success": true + }, + { + "mutex_wait_ns": 2386400, + "serialization_ns": 37300, + "serialized_bytes": 613, + "statement_ns": 3445200, + "success": true + }, + { + "mutex_wait_ns": 3403100, + "serialization_ns": 49800, + "serialized_bytes": 1036, + "statement_ns": 3599500, + "success": true + }, + { + "mutex_wait_ns": 3593400, + "serialization_ns": 33200, + "serialized_bytes": 613, + "statement_ns": 3668300, + "success": true + }, + { + "mutex_wait_ns": 3578200, + "serialization_ns": 59400, + "serialized_bytes": 1075, + "statement_ns": 4913900, + "success": true + }, + { + "mutex_wait_ns": 4869100, + "serialization_ns": 50300, + "serialized_bytes": 1040, + "statement_ns": 6903800, + "success": true + }, + { + "mutex_wait_ns": 6847900, + "serialization_ns": 58800, + "serialized_bytes": 1083, + "statement_ns": 2869700, + "success": true + }, + { + "mutex_wait_ns": 2780300, + "serialization_ns": 58300, + "serialized_bytes": 1079, + "statement_ns": 4249100, + "success": true + }, + { + "mutex_wait_ns": 4177200, + "serialization_ns": 64600, + "serialized_bytes": 1299, + "statement_ns": 2567100, + "success": true + }, + { + "mutex_wait_ns": 2516500, + "serialization_ns": 58300, + "serialized_bytes": 1087, + "statement_ns": 2831300, + "success": true + }, + { + "mutex_wait_ns": 2272400, + "serialization_ns": 30100, + "serialized_bytes": 613, + "statement_ns": 4961700, + "success": true + }, + { + "mutex_wait_ns": 4888500, + "serialization_ns": 62200, + "serialized_bytes": 1303, + "statement_ns": 4403600, + "success": true + }, + { + "mutex_wait_ns": 4393400, + "serialization_ns": 33600, + "serialized_bytes": 613, + "statement_ns": 3139200, + "success": true + }, + { + "mutex_wait_ns": 2557700, + "serialization_ns": 31000, + "serialized_bytes": 613, + "statement_ns": 3147600, + "success": true + }, + { + "mutex_wait_ns": 3095100, + "serialization_ns": 49600, + "serialized_bytes": 1040, + "statement_ns": 3317300, + "success": true + }, + { + "mutex_wait_ns": 3305000, + "serialization_ns": 33600, + "serialized_bytes": 613, + "statement_ns": 3184300, + "success": true + }, + { + "mutex_wait_ns": 3101500, + "serialization_ns": 56400, + "serialized_bytes": 1079, + "statement_ns": 3016300, + "success": true + }, + { + "mutex_wait_ns": 2973100, + "serialization_ns": 49000, + "serialized_bytes": 1040, + "statement_ns": 2498700, + "success": true + }, + { + "mutex_wait_ns": 2448300, + "serialization_ns": 54300, + "serialized_bytes": 1087, + "statement_ns": 3488700, + "success": true + }, + { + "mutex_wait_ns": 3410600, + "serialization_ns": 55300, + "serialized_bytes": 1079, + "statement_ns": 3935700, + "success": true + }, + { + "mutex_wait_ns": 3866300, + "serialization_ns": 60300, + "serialized_bytes": 1303, + "statement_ns": 5157800, + "success": true + }, + { + "mutex_wait_ns": 5108000, + "serialization_ns": 56200, + "serialized_bytes": 1087, + "statement_ns": 2746400, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 62600, + "serialized_bytes": 1303, + "statement_ns": 3054900, + "success": true + }, + { + "mutex_wait_ns": 2805600, + "serialization_ns": 29600, + "serialized_bytes": 613, + "statement_ns": 3210200, + "success": true + }, + { + "mutex_wait_ns": 2790700, + "serialization_ns": 30500, + "serialized_bytes": 611, + "statement_ns": 6488600, + "success": true + }, + { + "mutex_wait_ns": 6479400, + "serialization_ns": 33300, + "serialized_bytes": 613, + "statement_ns": 2760800, + "success": true + }, + { + "mutex_wait_ns": 2746400, + "serialization_ns": 37400, + "serialized_bytes": 611, + "statement_ns": 2699800, + "success": true + }, + { + "mutex_wait_ns": 2654100, + "serialization_ns": 52300, + "serialized_bytes": 1040, + "statement_ns": 2403600, + "success": true + }, + { + "mutex_wait_ns": 2367000, + "serialization_ns": 50000, + "serialized_bytes": 1036, + "statement_ns": 2653400, + "success": true + }, + { + "mutex_wait_ns": 2566700, + "serialization_ns": 54900, + "serialized_bytes": 1079, + "statement_ns": 3031500, + "success": true + }, + { + "mutex_wait_ns": 2966800, + "serialization_ns": 52700, + "serialized_bytes": 1075, + "statement_ns": 2632300, + "success": true + }, + { + "mutex_wait_ns": 2568400, + "serialization_ns": 68000, + "serialized_bytes": 1087, + "statement_ns": 2600000, + "success": true + }, + { + "mutex_wait_ns": 2562000, + "serialization_ns": 54200, + "serialized_bytes": 1083, + "statement_ns": 2388600, + "success": true + }, + { + "mutex_wait_ns": 2294900, + "serialization_ns": 78300, + "serialized_bytes": 1303, + "statement_ns": 2494600, + "success": true + }, + { + "mutex_wait_ns": 2436200, + "serialization_ns": 58800, + "serialized_bytes": 1299, + "statement_ns": 3367300, + "success": true + }, + { + "mutex_wait_ns": 2725600, + "serialization_ns": 35100, + "serialized_bytes": 611, + "statement_ns": 2886900, + "success": true + }, + { + "mutex_wait_ns": 2472100, + "serialization_ns": 28300, + "serialized_bytes": 613, + "statement_ns": 4161200, + "success": true + }, + { + "mutex_wait_ns": 4150500, + "serialization_ns": 38400, + "serialized_bytes": 611, + "statement_ns": 3054600, + "success": true + }, + { + "mutex_wait_ns": 3054000, + "serialization_ns": 31600, + "serialized_bytes": 613, + "statement_ns": 2512000, + "success": true + }, + { + "mutex_wait_ns": 2442200, + "serialization_ns": 62100, + "serialized_bytes": 1036, + "statement_ns": 2942500, + "success": true + }, + { + "mutex_wait_ns": 2899700, + "serialization_ns": 57800, + "serialized_bytes": 1040, + "statement_ns": 2547300, + "success": true + }, + { + "mutex_wait_ns": 2452800, + "serialization_ns": 69700, + "serialized_bytes": 1075, + "statement_ns": 2649200, + "success": true + }, + { + "mutex_wait_ns": 2582100, + "serialization_ns": 53700, + "serialized_bytes": 1079, + "statement_ns": 3037300, + "success": true + }, + { + "mutex_wait_ns": 2989400, + "serialization_ns": 54200, + "serialized_bytes": 1083, + "statement_ns": 2858700, + "success": true + }, + { + "mutex_wait_ns": 2818600, + "serialization_ns": 54100, + "serialized_bytes": 1087, + "statement_ns": 3103600, + "success": true + }, + { + "mutex_wait_ns": 3060900, + "serialization_ns": 59400, + "serialized_bytes": 1299, + "statement_ns": 4162100, + "success": true + }, + { + "mutex_wait_ns": 4121800, + "serialization_ns": 61400, + "serialized_bytes": 1303, + "statement_ns": 2824800, + "success": true + }, + { + "mutex_wait_ns": 1978500, + "serialization_ns": 30000, + "serialized_bytes": 613, + "statement_ns": 3332400, + "success": true + }, + { + "mutex_wait_ns": 2930400, + "serialization_ns": 29700, + "serialized_bytes": 613, + "statement_ns": 2888100, + "success": true + }, + { + "mutex_wait_ns": 2877600, + "serialization_ns": 33400, + "serialized_bytes": 613, + "statement_ns": 3111500, + "success": true + }, + { + "mutex_wait_ns": 3104300, + "serialization_ns": 33700, + "serialized_bytes": 613, + "statement_ns": 2470300, + "success": true + }, + { + "mutex_wait_ns": 2421700, + "serialization_ns": 51500, + "serialized_bytes": 1040, + "statement_ns": 2691100, + "success": true + }, + { + "mutex_wait_ns": 2650400, + "serialization_ns": 49400, + "serialized_bytes": 1040, + "statement_ns": 2688100, + "success": true + }, + { + "mutex_wait_ns": 2603200, + "serialization_ns": 56700, + "serialized_bytes": 1079, + "statement_ns": 2953600, + "success": true + }, + { + "mutex_wait_ns": 2885300, + "serialization_ns": 54400, + "serialized_bytes": 1079, + "statement_ns": 2829500, + "success": true + }, + { + "mutex_wait_ns": 2776300, + "serialization_ns": 55000, + "serialized_bytes": 1087, + "statement_ns": 3219500, + "success": true + }, + { + "mutex_wait_ns": 3179100, + "serialization_ns": 55400, + "serialized_bytes": 1087, + "statement_ns": 3096000, + "success": true + }, + { + "mutex_wait_ns": 3006600, + "serialization_ns": 81900, + "serialized_bytes": 1303, + "statement_ns": 2821600, + "success": true + }, + { + "mutex_wait_ns": 2766400, + "serialization_ns": 62900, + "serialized_bytes": 1303, + "statement_ns": 4289300, + "success": true + }, + { + "mutex_wait_ns": 1391900, + "serialization_ns": 38700, + "serialized_bytes": 613, + "statement_ns": 5054300, + "success": true + }, + { + "mutex_wait_ns": 4647500, + "serialization_ns": 28700, + "serialized_bytes": 613, + "statement_ns": 3129900, + "success": true + }, + { + "mutex_wait_ns": 3118400, + "serialization_ns": 34900, + "serialized_bytes": 613, + "statement_ns": 5097300, + "success": true + }, + { + "mutex_wait_ns": 5091300, + "serialization_ns": 34000, + "serialized_bytes": 613, + "statement_ns": 2298100, + "success": true + }, + { + "mutex_wait_ns": 2248400, + "serialization_ns": 53100, + "serialized_bytes": 1040, + "statement_ns": 2599600, + "success": true + }, + { + "mutex_wait_ns": 2554700, + "serialization_ns": 50700, + "serialized_bytes": 1040, + "statement_ns": 2634300, + "success": true + }, + { + "mutex_wait_ns": 2555100, + "serialization_ns": 57900, + "serialized_bytes": 1079, + "statement_ns": 4819900, + "success": true + }, + { + "mutex_wait_ns": 4762000, + "serialization_ns": 54200, + "serialized_bytes": 1079, + "statement_ns": 3217900, + "success": true + }, + { + "mutex_wait_ns": 3211700, + "serialization_ns": 56800, + "serialized_bytes": 1087, + "statement_ns": 2683600, + "success": true + }, + { + "mutex_wait_ns": 2680400, + "serialization_ns": 56900, + "serialized_bytes": 1087, + "statement_ns": 2537000, + "success": true + }, + { + "mutex_wait_ns": 2454200, + "serialization_ns": 66700, + "serialized_bytes": 1303, + "statement_ns": 3317400, + "success": true + }, + { + "mutex_wait_ns": 3251800, + "serialization_ns": 62400, + "serialized_bytes": 1303, + "statement_ns": 4018900, + "success": true + }, + { + "mutex_wait_ns": 3613200, + "serialization_ns": 57600, + "serialized_bytes": 613, + "statement_ns": 3363800, + "success": true + }, + { + "mutex_wait_ns": 2866400, + "serialization_ns": 30600, + "serialized_bytes": 613, + "statement_ns": 2893900, + "success": true + }, + { + "mutex_wait_ns": 2894000, + "serialization_ns": 34400, + "serialized_bytes": 613, + "statement_ns": 2856800, + "success": true + }, + { + "mutex_wait_ns": 2858700, + "serialization_ns": 32000, + "serialized_bytes": 613, + "statement_ns": 2380800, + "success": true + }, + { + "mutex_wait_ns": 2332500, + "serialization_ns": 50600, + "serialized_bytes": 1040, + "statement_ns": 2817900, + "success": true + }, + { + "mutex_wait_ns": 2776700, + "serialization_ns": 49100, + "serialized_bytes": 1040, + "statement_ns": 2883200, + "success": true + }, + { + "mutex_wait_ns": 2807200, + "serialization_ns": 52100, + "serialized_bytes": 1079, + "statement_ns": 4693200, + "success": true + }, + { + "mutex_wait_ns": 4628200, + "serialization_ns": 53000, + "serialized_bytes": 1079, + "statement_ns": 2449000, + "success": true + }, + { + "mutex_wait_ns": 2416300, + "serialization_ns": 54900, + "serialized_bytes": 1087, + "statement_ns": 2933600, + "success": true + }, + { + "mutex_wait_ns": 2912800, + "serialization_ns": 54000, + "serialized_bytes": 1087, + "statement_ns": 2750600, + "success": true + }, + { + "mutex_wait_ns": 2672600, + "serialization_ns": 64200, + "serialized_bytes": 1303, + "statement_ns": 2655400, + "success": true + }, + { + "mutex_wait_ns": 2592700, + "serialization_ns": 60000, + "serialized_bytes": 1303, + "statement_ns": 2995400, + "success": true + }, + { + "mutex_wait_ns": 2169000, + "serialization_ns": 28900, + "serialized_bytes": 613, + "statement_ns": 2820100, + "success": true + }, + { + "mutex_wait_ns": 2426600, + "serialization_ns": 29800, + "serialized_bytes": 611, + "statement_ns": 3118600, + "success": true + }, + { + "mutex_wait_ns": 3070900, + "serialization_ns": 75300, + "serialized_bytes": 613, + "statement_ns": 2770300, + "success": true + }, + { + "mutex_wait_ns": 2766100, + "serialization_ns": 33500, + "serialized_bytes": 611, + "statement_ns": 4125200, + "success": true + }, + { + "mutex_wait_ns": 4074500, + "serialization_ns": 50600, + "serialized_bytes": 1040, + "statement_ns": 2566500, + "success": true + }, + { + "mutex_wait_ns": 2524000, + "serialization_ns": 48500, + "serialized_bytes": 1036, + "statement_ns": 2272100, + "success": true + }, + { + "mutex_wait_ns": 2187200, + "serialization_ns": 54300, + "serialized_bytes": 1079, + "statement_ns": 2819500, + "success": true + }, + { + "mutex_wait_ns": 2756200, + "serialization_ns": 50500, + "serialized_bytes": 1075, + "statement_ns": 2680700, + "success": true + }, + { + "mutex_wait_ns": 2629100, + "serialization_ns": 54300, + "serialized_bytes": 1087, + "statement_ns": 5518200, + "success": true + }, + { + "mutex_wait_ns": 5477500, + "serialization_ns": 53500, + "serialized_bytes": 1083, + "statement_ns": 2620500, + "success": true + }, + { + "mutex_wait_ns": 2541000, + "serialization_ns": 62600, + "serialized_bytes": 1303, + "statement_ns": 2599000, + "success": true + }, + { + "mutex_wait_ns": 2530100, + "serialization_ns": 61400, + "serialized_bytes": 1299, + "statement_ns": 2975600, + "success": true + }, + { + "mutex_wait_ns": 2257100, + "serialization_ns": 29000, + "serialized_bytes": 611, + "statement_ns": 5525800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 31700, + "serialized_bytes": 611, + "statement_ns": 2705000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48800, + "serialized_bytes": 1036, + "statement_ns": 2385500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 49800, + "serialized_bytes": 1075, + "statement_ns": 2560900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 78600, + "serialized_bytes": 1083, + "statement_ns": 2395500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 60000, + "serialized_bytes": 1299, + "statement_ns": 2311400, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 2019500, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=0", + "COMPILER=msvc-1944", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_W32", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "TLS", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 675943400, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 210958500, + 369181500, + 369392400, + 368485000, + 368419500, + 368619700, + 367735800, + 368683900, + 368300900, + 368792400, + 367989100, + 406018400, + 405143400, + 406406900, + 405235200, + 443159600, + 446732100, + 654590000, + 657426400, + 654954000, + 656739600, + 657754700, + 655300000, + 656501100, + 656425200, + 655864800, + 655793000, + 657755900, + 657213300, + 657685200, + 656553800, + 672531700 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 4140900, + 38896300, + 312618500, + 265499500, + 554200, + 390900, + 456800, + 573500 + ], + "failures": 0, + "in_window_samples": 5, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 4140900, + "end_ns": 15345200, + "in_window": true, + "scheduled_ns": null, + "start_ns": 11204300, + "success": true + }, + { + "elapsed_ns": 38896300, + "end_ns": 64487300, + "in_window": true, + "scheduled_ns": null, + "start_ns": 25591000, + "success": true + }, + { + "elapsed_ns": 312618500, + "end_ns": 387623600, + "in_window": true, + "scheduled_ns": null, + "start_ns": 75005100, + "success": true + }, + { + "elapsed_ns": 265499500, + "end_ns": 663258200, + "in_window": true, + "scheduled_ns": null, + "start_ns": 397758700, + "success": true + }, + { + "elapsed_ns": 554200, + "end_ns": 674122800, + "in_window": true, + "scheduled_ns": null, + "start_ns": 673568600, + "success": true + }, + { + "elapsed_ns": 390900, + "end_ns": 684685000, + "in_window": false, + "scheduled_ns": null, + "start_ns": 684294100, + "success": true + }, + { + "elapsed_ns": 456800, + "end_ns": 695380400, + "in_window": false, + "scheduled_ns": null, + "start_ns": 694923600, + "success": true + }, + { + "elapsed_ns": 573500, + "end_ns": 706116800, + "in_window": false, + "scheduled_ns": null, + "start_ns": 705543300, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 2100700, + 13902400, + 22796300, + 257388300, + 40751100, + 280811400, + 4032100, + 9668500, + 10642600 + ], + "failures": 0, + "in_window_samples": 7, + "missed_periods": 61, + "samples": [ + { + "elapsed_ns": 2100700, + "end_ns": 17378200, + "in_window": true, + "scheduled_ns": 15277500, + "start_ns": 17378200, + "success": true + }, + { + "elapsed_ns": 13902400, + "end_ns": 39179900, + "in_window": true, + "scheduled_ns": 25277500, + "start_ns": 39179900, + "success": true + }, + { + "elapsed_ns": 22796300, + "end_ns": 68073800, + "in_window": true, + "scheduled_ns": 45277500, + "start_ns": 68073800, + "success": true + }, + { + "elapsed_ns": 257388300, + "end_ns": 332665800, + "in_window": true, + "scheduled_ns": 75277500, + "start_ns": 332665800, + "success": true + }, + { + "elapsed_ns": 40751100, + "end_ns": 376028600, + "in_window": true, + "scheduled_ns": 335277500, + "start_ns": 376028600, + "success": true + }, + { + "elapsed_ns": 280811400, + "end_ns": 666088900, + "in_window": true, + "scheduled_ns": 385277500, + "start_ns": 666088900, + "success": true + }, + { + "elapsed_ns": 4032100, + "end_ns": 679309600, + "in_window": true, + "scheduled_ns": 675277500, + "start_ns": 679309600, + "success": true + }, + { + "elapsed_ns": 9668500, + "end_ns": 694946000, + "in_window": false, + "scheduled_ns": 685277500, + "start_ns": 694946000, + "success": true + }, + { + "elapsed_ns": 10642600, + "end_ns": 705920100, + "in_window": false, + "scheduled_ns": 695277500, + "start_ns": 705920100, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 681247400, + "window_start_ns": 5304000 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 1, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 600, + "serialization_ns": 36500, + "serialized_bytes": 613, + "statement_ns": 3825300, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 37500, + "serialized_bytes": 613, + "statement_ns": 2895200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52200, + "serialized_bytes": 1040, + "statement_ns": 2625500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 52900, + "serialized_bytes": 1079, + "statement_ns": 2404700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 55400, + "serialized_bytes": 1087, + "statement_ns": 2790200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 60500, + "serialized_bytes": 1303, + "statement_ns": 2556000, + "success": true + }, + { + "mutex_wait_ns": 500, + "serialization_ns": 40000, + "serialized_bytes": 613, + "statement_ns": 4456800, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 35500, + "serialized_bytes": 613, + "statement_ns": 2722300, + "success": true + }, + { + "mutex_wait_ns": 2043900, + "serialization_ns": 34500, + "serialized_bytes": 613, + "statement_ns": 4359300, + "success": true + }, + { + "mutex_wait_ns": 4306800, + "serialization_ns": 52100, + "serialized_bytes": 1040, + "statement_ns": 2730300, + "success": true + }, + { + "mutex_wait_ns": 2710500, + "serialization_ns": 33900, + "serialized_bytes": 613, + "statement_ns": 2883300, + "success": true + }, + { + "mutex_wait_ns": 2792600, + "serialization_ns": 57000, + "serialized_bytes": 1079, + "statement_ns": 2800700, + "success": true + }, + { + "mutex_wait_ns": 2747800, + "serialization_ns": 49400, + "serialized_bytes": 1040, + "statement_ns": 3644800, + "success": true + }, + { + "mutex_wait_ns": 3592000, + "serialization_ns": 55900, + "serialized_bytes": 1087, + "statement_ns": 2806800, + "success": true + }, + { + "mutex_wait_ns": 2727800, + "serialization_ns": 51800, + "serialized_bytes": 1079, + "statement_ns": 2603800, + "success": true + }, + { + "mutex_wait_ns": 2533000, + "serialization_ns": 60500, + "serialized_bytes": 1303, + "statement_ns": 3115700, + "success": true + }, + { + "mutex_wait_ns": 3065500, + "serialization_ns": 53900, + "serialized_bytes": 1087, + "statement_ns": 2942500, + "success": true + }, + { + "mutex_wait_ns": 2409500, + "serialization_ns": 29000, + "serialized_bytes": 613, + "statement_ns": 4357800, + "success": true + }, + { + "mutex_wait_ns": 4276800, + "serialization_ns": 61200, + "serialized_bytes": 1303, + "statement_ns": 3521900, + "success": true + }, + { + "mutex_wait_ns": 3504800, + "serialization_ns": 35700, + "serialized_bytes": 613, + "statement_ns": 2747400, + "success": true + }, + { + "mutex_wait_ns": 2218200, + "serialization_ns": 30000, + "serialized_bytes": 613, + "statement_ns": 3022500, + "success": true + }, + { + "mutex_wait_ns": 2938300, + "serialization_ns": 81000, + "serialized_bytes": 1040, + "statement_ns": 3245300, + "success": true + }, + { + "mutex_wait_ns": 3235800, + "serialization_ns": 31600, + "serialized_bytes": 613, + "statement_ns": 2372400, + "success": true + }, + { + "mutex_wait_ns": 2292700, + "serialization_ns": 55400, + "serialized_bytes": 1079, + "statement_ns": 2737900, + "success": true + }, + { + "mutex_wait_ns": 2688800, + "serialization_ns": 48200, + "serialized_bytes": 1040, + "statement_ns": 2394700, + "success": true + }, + { + "mutex_wait_ns": 2345300, + "serialization_ns": 53400, + "serialized_bytes": 1087, + "statement_ns": 2366600, + "success": true + }, + { + "mutex_wait_ns": 2283000, + "serialization_ns": 57000, + "serialized_bytes": 1079, + "statement_ns": 2714100, + "success": true + }, + { + "mutex_wait_ns": 2601100, + "serialization_ns": 102600, + "serialized_bytes": 1303, + "statement_ns": 2732000, + "success": true + }, + { + "mutex_wait_ns": 2661100, + "serialization_ns": 83700, + "serialized_bytes": 1087, + "statement_ns": 2946300, + "success": true + }, + { + "mutex_wait_ns": 2396000, + "serialization_ns": 28500, + "serialized_bytes": 613, + "statement_ns": 7719000, + "success": true + }, + { + "mutex_wait_ns": 7611300, + "serialization_ns": 97200, + "serialized_bytes": 1303, + "statement_ns": 4359700, + "success": true + }, + { + "mutex_wait_ns": 4340300, + "serialization_ns": 38900, + "serialized_bytes": 613, + "statement_ns": 2973900, + "success": true + }, + { + "mutex_wait_ns": 2420700, + "serialization_ns": 30600, + "serialized_bytes": 613, + "statement_ns": 3581900, + "success": true + }, + { + "mutex_wait_ns": 3538000, + "serialization_ns": 49200, + "serialized_bytes": 1040, + "statement_ns": 2632100, + "success": true + }, + { + "mutex_wait_ns": 2617800, + "serialization_ns": 33200, + "serialized_bytes": 613, + "statement_ns": 2727300, + "success": true + }, + { + "mutex_wait_ns": 2646800, + "serialization_ns": 54900, + "serialized_bytes": 1079, + "statement_ns": 3598400, + "success": true + }, + { + "mutex_wait_ns": 3548300, + "serialization_ns": 49500, + "serialized_bytes": 1040, + "statement_ns": 4031100, + "success": true + }, + { + "mutex_wait_ns": 3974500, + "serialization_ns": 55500, + "serialized_bytes": 1087, + "statement_ns": 2916000, + "success": true + }, + { + "mutex_wait_ns": 2829500, + "serialization_ns": 55800, + "serialized_bytes": 1079, + "statement_ns": 2979000, + "success": true + }, + { + "mutex_wait_ns": 2941800, + "serialization_ns": 59800, + "serialized_bytes": 1303, + "statement_ns": 3403100, + "success": true + }, + { + "mutex_wait_ns": 3352300, + "serialization_ns": 53900, + "serialized_bytes": 1087, + "statement_ns": 2722800, + "success": true + }, + { + "mutex_wait_ns": 2192300, + "serialization_ns": 29200, + "serialized_bytes": 613, + "statement_ns": 3192400, + "success": true + }, + { + "mutex_wait_ns": 3117300, + "serialization_ns": 61800, + "serialized_bytes": 1303, + "statement_ns": 3194700, + "success": true + }, + { + "mutex_wait_ns": 3181300, + "serialization_ns": 32600, + "serialized_bytes": 613, + "statement_ns": 2924900, + "success": true + }, + { + "mutex_wait_ns": 2398900, + "serialization_ns": 29400, + "serialized_bytes": 613, + "statement_ns": 3769400, + "success": true + }, + { + "mutex_wait_ns": 3721800, + "serialization_ns": 49100, + "serialized_bytes": 1040, + "statement_ns": 2569900, + "success": true + }, + { + "mutex_wait_ns": 2553900, + "serialization_ns": 33300, + "serialized_bytes": 613, + "statement_ns": 3904700, + "success": true + }, + { + "mutex_wait_ns": 3829700, + "serialization_ns": 52600, + "serialized_bytes": 1079, + "statement_ns": 2916300, + "success": true + }, + { + "mutex_wait_ns": 2865100, + "serialization_ns": 50700, + "serialized_bytes": 1040, + "statement_ns": 3139200, + "success": true + }, + { + "mutex_wait_ns": 3085700, + "serialization_ns": 54500, + "serialized_bytes": 1087, + "statement_ns": 3297100, + "success": true + }, + { + "mutex_wait_ns": 3215500, + "serialization_ns": 55800, + "serialized_bytes": 1079, + "statement_ns": 2959600, + "success": true + }, + { + "mutex_wait_ns": 2891000, + "serialization_ns": 60500, + "serialized_bytes": 1303, + "statement_ns": 3566700, + "success": true + }, + { + "mutex_wait_ns": 3515700, + "serialization_ns": 56700, + "serialized_bytes": 1087, + "statement_ns": 3169900, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 61400, + "serialized_bytes": 1303, + "statement_ns": 2943600, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 51800, + "serialized_bytes": 613, + "statement_ns": 4153300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 32200, + "serialized_bytes": 613, + "statement_ns": 2757400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 48200, + "serialized_bytes": 1040, + "statement_ns": 3148700, + "success": true + }, + { + "mutex_wait_ns": 5996000, + "serialization_ns": 30800, + "serialized_bytes": 611, + "statement_ns": 3662100, + "success": true + }, + { + "mutex_wait_ns": 3592500, + "serialization_ns": 51600, + "serialized_bytes": 1079, + "statement_ns": 3112900, + "success": true + }, + { + "mutex_wait_ns": 3094900, + "serialization_ns": 34000, + "serialized_bytes": 611, + "statement_ns": 3094200, + "success": true + }, + { + "mutex_wait_ns": 3044900, + "serialization_ns": 53800, + "serialized_bytes": 1087, + "statement_ns": 3158400, + "success": true + }, + { + "mutex_wait_ns": 3105100, + "serialization_ns": 49500, + "serialized_bytes": 1036, + "statement_ns": 3642000, + "success": true + }, + { + "mutex_wait_ns": 3564000, + "serialization_ns": 61300, + "serialized_bytes": 1303, + "statement_ns": 2862100, + "success": true + }, + { + "mutex_wait_ns": 2790400, + "serialization_ns": 52200, + "serialized_bytes": 1075, + "statement_ns": 2590900, + "success": true + }, + { + "mutex_wait_ns": 2069600, + "serialization_ns": 29500, + "serialized_bytes": 613, + "statement_ns": 2904200, + "success": true + }, + { + "mutex_wait_ns": 2858600, + "serialization_ns": 54300, + "serialized_bytes": 1083, + "statement_ns": 4010800, + "success": true + }, + { + "mutex_wait_ns": 3976400, + "serialization_ns": 32100, + "serialized_bytes": 613, + "statement_ns": 2811700, + "success": true + }, + { + "mutex_wait_ns": 2723300, + "serialization_ns": 64900, + "serialized_bytes": 1299, + "statement_ns": 2871200, + "success": true + }, + { + "mutex_wait_ns": 2822900, + "serialization_ns": 48700, + "serialized_bytes": 1040, + "statement_ns": 2365400, + "success": true + }, + { + "mutex_wait_ns": 1830800, + "serialization_ns": 29200, + "serialized_bytes": 613, + "statement_ns": 3049200, + "success": true + }, + { + "mutex_wait_ns": 2984000, + "serialization_ns": 51000, + "serialized_bytes": 1079, + "statement_ns": 3489700, + "success": true + }, + { + "mutex_wait_ns": 3478300, + "serialization_ns": 32100, + "serialized_bytes": 613, + "statement_ns": 2554300, + "success": true + }, + { + "mutex_wait_ns": 2508100, + "serialization_ns": 53200, + "serialized_bytes": 1087, + "statement_ns": 2458000, + "success": true + }, + { + "mutex_wait_ns": 2412100, + "serialization_ns": 48300, + "serialized_bytes": 1040, + "statement_ns": 2781200, + "success": true + }, + { + "mutex_wait_ns": 2711900, + "serialization_ns": 59600, + "serialized_bytes": 1303, + "statement_ns": 3980900, + "success": true + }, + { + "mutex_wait_ns": 3911100, + "serialization_ns": 51300, + "serialized_bytes": 1079, + "statement_ns": 2805200, + "success": true + }, + { + "mutex_wait_ns": 2268800, + "serialization_ns": 30300, + "serialized_bytes": 613, + "statement_ns": 2927200, + "success": true + }, + { + "mutex_wait_ns": 2881300, + "serialization_ns": 53700, + "serialized_bytes": 1087, + "statement_ns": 3455300, + "success": true + }, + { + "mutex_wait_ns": 3444700, + "serialization_ns": 31700, + "serialized_bytes": 613, + "statement_ns": 3064900, + "success": true + }, + { + "mutex_wait_ns": 2984000, + "serialization_ns": 64700, + "serialized_bytes": 1303, + "statement_ns": 2976200, + "success": true + }, + { + "mutex_wait_ns": 2930700, + "serialization_ns": 48100, + "serialized_bytes": 1040, + "statement_ns": 3763300, + "success": true + }, + { + "mutex_wait_ns": 3228700, + "serialization_ns": 29100, + "serialized_bytes": 611, + "statement_ns": 2995700, + "success": true + }, + { + "mutex_wait_ns": 2919100, + "serialization_ns": 55200, + "serialized_bytes": 1079, + "statement_ns": 4473900, + "success": true + }, + { + "mutex_wait_ns": 4460400, + "serialization_ns": 33700, + "serialized_bytes": 611, + "statement_ns": 3086200, + "success": true + }, + { + "mutex_wait_ns": 3030400, + "serialization_ns": 58200, + "serialized_bytes": 1087, + "statement_ns": 3974200, + "success": true + }, + { + "mutex_wait_ns": 3921600, + "serialization_ns": 51600, + "serialized_bytes": 1036, + "statement_ns": 2629700, + "success": true + }, + { + "mutex_wait_ns": 2541700, + "serialization_ns": 66300, + "serialized_bytes": 1303, + "statement_ns": 2838800, + "success": true + }, + { + "mutex_wait_ns": 2766900, + "serialization_ns": 52100, + "serialized_bytes": 1075, + "statement_ns": 5941500, + "success": true + }, + { + "mutex_wait_ns": 5106200, + "serialization_ns": 29500, + "serialized_bytes": 613, + "statement_ns": 3152500, + "success": true + }, + { + "mutex_wait_ns": 3097400, + "serialization_ns": 58900, + "serialized_bytes": 1083, + "statement_ns": 2723000, + "success": true + }, + { + "mutex_wait_ns": 2708700, + "serialization_ns": 34000, + "serialized_bytes": 613, + "statement_ns": 2631000, + "success": true + }, + { + "mutex_wait_ns": 2543200, + "serialization_ns": 65800, + "serialized_bytes": 1299, + "statement_ns": 4649700, + "success": true + }, + { + "mutex_wait_ns": 4604700, + "serialization_ns": 48700, + "serialized_bytes": 1040, + "statement_ns": 4282700, + "success": true + }, + { + "mutex_wait_ns": 3753800, + "serialization_ns": 30300, + "serialized_bytes": 613, + "statement_ns": 2877000, + "success": true + }, + { + "mutex_wait_ns": 2810800, + "serialization_ns": 54700, + "serialized_bytes": 1079, + "statement_ns": 3517800, + "success": true + }, + { + "mutex_wait_ns": 3498500, + "serialization_ns": 35100, + "serialized_bytes": 613, + "statement_ns": 3657200, + "success": true + }, + { + "mutex_wait_ns": 3606000, + "serialization_ns": 56800, + "serialized_bytes": 1087, + "statement_ns": 2530000, + "success": true + }, + { + "mutex_wait_ns": 2474600, + "serialization_ns": 50300, + "serialized_bytes": 1040, + "statement_ns": 2556600, + "success": true + }, + { + "mutex_wait_ns": 2475400, + "serialization_ns": 63900, + "serialized_bytes": 1303, + "statement_ns": 3229800, + "success": true + }, + { + "mutex_wait_ns": 3158700, + "serialization_ns": 52100, + "serialized_bytes": 1079, + "statement_ns": 2122100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 54300, + "serialized_bytes": 1087, + "statement_ns": 2120300, + "success": true + }, + { + "mutex_wait_ns": 1712600, + "serialization_ns": 29100, + "serialized_bytes": 611, + "statement_ns": 2831000, + "success": true + }, + { + "mutex_wait_ns": 2767700, + "serialization_ns": 60100, + "serialized_bytes": 1303, + "statement_ns": 5831300, + "success": true + }, + { + "mutex_wait_ns": 5824100, + "serialization_ns": 32700, + "serialized_bytes": 611, + "statement_ns": 2419400, + "success": true + }, + { + "mutex_wait_ns": 1730300, + "serialization_ns": 30600, + "serialized_bytes": 611, + "statement_ns": 2559000, + "success": true + }, + { + "mutex_wait_ns": 2516600, + "serialization_ns": 48500, + "serialized_bytes": 1036, + "statement_ns": 3288400, + "success": true + }, + { + "mutex_wait_ns": 3275800, + "serialization_ns": 32900, + "serialized_bytes": 611, + "statement_ns": 2561300, + "success": true + }, + { + "mutex_wait_ns": 2484000, + "serialization_ns": 54800, + "serialized_bytes": 1075, + "statement_ns": 2602500, + "success": true + }, + { + "mutex_wait_ns": 2557200, + "serialization_ns": 48600, + "serialized_bytes": 1036, + "statement_ns": 2597700, + "success": true + }, + { + "mutex_wait_ns": 2558600, + "serialization_ns": 54100, + "serialized_bytes": 1083, + "statement_ns": 2962100, + "success": true + }, + { + "mutex_wait_ns": 2858900, + "serialization_ns": 83000, + "serialized_bytes": 1075, + "statement_ns": 2439600, + "success": true + }, + { + "mutex_wait_ns": 2370200, + "serialization_ns": 62300, + "serialized_bytes": 1299, + "statement_ns": 2707000, + "success": true + }, + { + "mutex_wait_ns": 2659900, + "serialization_ns": 53900, + "serialized_bytes": 1083, + "statement_ns": 5628400, + "success": true + }, + { + "mutex_wait_ns": 4243400, + "serialization_ns": 29100, + "serialized_bytes": 611, + "statement_ns": 3010900, + "success": true + }, + { + "mutex_wait_ns": 2944500, + "serialization_ns": 61000, + "serialized_bytes": 1299, + "statement_ns": 2528200, + "success": true + }, + { + "mutex_wait_ns": 2513800, + "serialization_ns": 33600, + "serialized_bytes": 611, + "statement_ns": 3315800, + "success": true + }, + { + "mutex_wait_ns": 2835800, + "serialization_ns": 30000, + "serialized_bytes": 613, + "statement_ns": 2956600, + "success": true + }, + { + "mutex_wait_ns": 2906900, + "serialization_ns": 49100, + "serialized_bytes": 1036, + "statement_ns": 6224300, + "success": true + }, + { + "mutex_wait_ns": 6211600, + "serialization_ns": 30900, + "serialized_bytes": 613, + "statement_ns": 2622800, + "success": true + }, + { + "mutex_wait_ns": 2531900, + "serialization_ns": 58800, + "serialized_bytes": 1075, + "statement_ns": 2439800, + "success": true + }, + { + "mutex_wait_ns": 2390700, + "serialization_ns": 50400, + "serialized_bytes": 1040, + "statement_ns": 2793800, + "success": true + }, + { + "mutex_wait_ns": 2744200, + "serialization_ns": 53700, + "serialized_bytes": 1083, + "statement_ns": 3667500, + "success": true + }, + { + "mutex_wait_ns": 3593300, + "serialization_ns": 52700, + "serialized_bytes": 1079, + "statement_ns": 2554700, + "success": true + }, + { + "mutex_wait_ns": 2485400, + "serialization_ns": 59700, + "serialized_bytes": 1299, + "statement_ns": 2789100, + "success": true + }, + { + "mutex_wait_ns": 2746300, + "serialization_ns": 53300, + "serialized_bytes": 1087, + "statement_ns": 2697100, + "success": true + }, + { + "mutex_wait_ns": 1682900, + "serialization_ns": 28900, + "serialized_bytes": 613, + "statement_ns": 5382500, + "success": true + }, + { + "mutex_wait_ns": 5316700, + "serialization_ns": 61200, + "serialized_bytes": 1303, + "statement_ns": 7091400, + "success": true + }, + { + "mutex_wait_ns": 7074800, + "serialization_ns": 35700, + "serialized_bytes": 613, + "statement_ns": 3028700, + "success": true + }, + { + "mutex_wait_ns": 2481400, + "serialization_ns": 30800, + "serialized_bytes": 613, + "statement_ns": 6971900, + "success": true + }, + { + "mutex_wait_ns": 6921300, + "serialization_ns": 50400, + "serialized_bytes": 1040, + "statement_ns": 2799600, + "success": true + }, + { + "mutex_wait_ns": 2776600, + "serialization_ns": 33500, + "serialized_bytes": 613, + "statement_ns": 2771500, + "success": true + }, + { + "mutex_wait_ns": 2689700, + "serialization_ns": 54600, + "serialized_bytes": 1079, + "statement_ns": 2709000, + "success": true + }, + { + "mutex_wait_ns": 2662100, + "serialization_ns": 49100, + "serialized_bytes": 1040, + "statement_ns": 2972000, + "success": true + }, + { + "mutex_wait_ns": 2918100, + "serialization_ns": 54700, + "serialized_bytes": 1087, + "statement_ns": 3174500, + "success": true + }, + { + "mutex_wait_ns": 3093500, + "serialization_ns": 54500, + "serialized_bytes": 1079, + "statement_ns": 3054500, + "success": true + }, + { + "mutex_wait_ns": 2963900, + "serialization_ns": 76900, + "serialized_bytes": 1303, + "statement_ns": 2808100, + "success": true + }, + { + "mutex_wait_ns": 2760600, + "serialization_ns": 57600, + "serialized_bytes": 1087, + "statement_ns": 2836100, + "success": true + }, + { + "mutex_wait_ns": 2188800, + "serialization_ns": 35600, + "serialized_bytes": 611, + "statement_ns": 4704600, + "success": true + }, + { + "mutex_wait_ns": 4676300, + "serialization_ns": 64100, + "serialized_bytes": 1303, + "statement_ns": 4062000, + "success": true + }, + { + "mutex_wait_ns": 4168900, + "serialization_ns": 32800, + "serialized_bytes": 611, + "statement_ns": 2586800, + "success": true + }, + { + "mutex_wait_ns": 2135400, + "serialization_ns": 31100, + "serialized_bytes": 613, + "statement_ns": 5522100, + "success": true + }, + { + "mutex_wait_ns": 5474100, + "serialization_ns": 51600, + "serialized_bytes": 1036, + "statement_ns": 2677200, + "success": true + }, + { + "mutex_wait_ns": 2655600, + "serialization_ns": 36000, + "serialized_bytes": 613, + "statement_ns": 2503400, + "success": true + }, + { + "mutex_wait_ns": 2410300, + "serialization_ns": 57300, + "serialized_bytes": 1075, + "statement_ns": 2353900, + "success": true + }, + { + "mutex_wait_ns": 2306500, + "serialization_ns": 48800, + "serialized_bytes": 1040, + "statement_ns": 2800500, + "success": true + }, + { + "mutex_wait_ns": 2750100, + "serialization_ns": 53000, + "serialized_bytes": 1083, + "statement_ns": 2834200, + "success": true + }, + { + "mutex_wait_ns": 2759200, + "serialization_ns": 53500, + "serialized_bytes": 1079, + "statement_ns": 3019700, + "success": true + }, + { + "mutex_wait_ns": 2951500, + "serialization_ns": 60800, + "serialized_bytes": 1299, + "statement_ns": 3371000, + "success": true + }, + { + "mutex_wait_ns": 3322400, + "serialization_ns": 53100, + "serialized_bytes": 1087, + "statement_ns": 2817500, + "success": true + }, + { + "mutex_wait_ns": 2051700, + "serialization_ns": 28400, + "serialized_bytes": 611, + "statement_ns": 6266400, + "success": true + }, + { + "mutex_wait_ns": 6201000, + "serialization_ns": 61300, + "serialized_bytes": 1303, + "statement_ns": 2808900, + "success": true + }, + { + "mutex_wait_ns": 2797900, + "serialization_ns": 31900, + "serialized_bytes": 611, + "statement_ns": 3309600, + "success": true + }, + { + "mutex_wait_ns": 2854200, + "serialization_ns": 28000, + "serialized_bytes": 613, + "statement_ns": 2979900, + "success": true + }, + { + "mutex_wait_ns": 2936400, + "serialization_ns": 47600, + "serialized_bytes": 1036, + "statement_ns": 2478600, + "success": true + }, + { + "mutex_wait_ns": 2466200, + "serialization_ns": 31500, + "serialized_bytes": 613, + "statement_ns": 2737900, + "success": true + }, + { + "mutex_wait_ns": 2679700, + "serialization_ns": 53200, + "serialized_bytes": 1075, + "statement_ns": 2575100, + "success": true + }, + { + "mutex_wait_ns": 2544300, + "serialization_ns": 47100, + "serialized_bytes": 1040, + "statement_ns": 3081500, + "success": true + }, + { + "mutex_wait_ns": 3037900, + "serialization_ns": 52200, + "serialized_bytes": 1083, + "statement_ns": 3114200, + "success": true + }, + { + "mutex_wait_ns": 3046200, + "serialization_ns": 52400, + "serialized_bytes": 1079, + "statement_ns": 2611900, + "success": true + }, + { + "mutex_wait_ns": 2544300, + "serialization_ns": 60100, + "serialized_bytes": 1299, + "statement_ns": 4398800, + "success": true + }, + { + "mutex_wait_ns": 4356200, + "serialization_ns": 52700, + "serialized_bytes": 1087, + "statement_ns": 2678200, + "success": true + }, + { + "mutex_wait_ns": 2157100, + "serialization_ns": 29200, + "serialized_bytes": 613, + "statement_ns": 3426400, + "success": true + }, + { + "mutex_wait_ns": 3363900, + "serialization_ns": 60000, + "serialized_bytes": 1303, + "statement_ns": 2684700, + "success": true + }, + { + "mutex_wait_ns": 2673300, + "serialization_ns": 31900, + "serialized_bytes": 613, + "statement_ns": 2306900, + "success": true + }, + { + "mutex_wait_ns": 1814500, + "serialization_ns": 29300, + "serialized_bytes": 611, + "statement_ns": 2843600, + "success": true + }, + { + "mutex_wait_ns": 2803000, + "serialization_ns": 48000, + "serialized_bytes": 1040, + "statement_ns": 2924100, + "success": true + }, + { + "mutex_wait_ns": 2914200, + "serialization_ns": 31500, + "serialized_bytes": 611, + "statement_ns": 3826300, + "success": true + }, + { + "mutex_wait_ns": 3732900, + "serialization_ns": 64700, + "serialized_bytes": 1079, + "statement_ns": 2933200, + "success": true + }, + { + "mutex_wait_ns": 2895700, + "serialization_ns": 48300, + "serialized_bytes": 1036, + "statement_ns": 2779900, + "success": true + }, + { + "mutex_wait_ns": 2633200, + "serialization_ns": 81000, + "serialized_bytes": 1087, + "statement_ns": 3068100, + "success": true + }, + { + "mutex_wait_ns": 3000100, + "serialization_ns": 50400, + "serialized_bytes": 1075, + "statement_ns": 3102700, + "success": true + }, + { + "mutex_wait_ns": 3014000, + "serialization_ns": 77800, + "serialized_bytes": 1303, + "statement_ns": 2842000, + "success": true + }, + { + "mutex_wait_ns": 2797400, + "serialization_ns": 52000, + "serialized_bytes": 1083, + "statement_ns": 2355200, + "success": true + }, + { + "mutex_wait_ns": 1759600, + "serialization_ns": 37100, + "serialized_bytes": 611, + "statement_ns": 3213100, + "success": true + }, + { + "mutex_wait_ns": 3151100, + "serialization_ns": 61400, + "serialized_bytes": 1299, + "statement_ns": 4622400, + "success": true + }, + { + "mutex_wait_ns": 4598300, + "serialization_ns": 40200, + "serialized_bytes": 611, + "statement_ns": 3943300, + "success": true + }, + { + "mutex_wait_ns": 3402700, + "serialization_ns": 28600, + "serialized_bytes": 613, + "statement_ns": 4506100, + "success": true + }, + { + "mutex_wait_ns": 4464000, + "serialization_ns": 49800, + "serialized_bytes": 1036, + "statement_ns": 3121300, + "success": true + }, + { + "mutex_wait_ns": 3124000, + "serialization_ns": 35500, + "serialized_bytes": 613, + "statement_ns": 3639400, + "success": true + }, + { + "mutex_wait_ns": 3570700, + "serialization_ns": 56700, + "serialized_bytes": 1075, + "statement_ns": 3420100, + "success": true + }, + { + "mutex_wait_ns": 3370000, + "serialization_ns": 52100, + "serialized_bytes": 1040, + "statement_ns": 2597100, + "success": true + }, + { + "mutex_wait_ns": 2543000, + "serialization_ns": 56000, + "serialized_bytes": 1083, + "statement_ns": 2906000, + "success": true + }, + { + "mutex_wait_ns": 2817100, + "serialization_ns": 58300, + "serialized_bytes": 1079, + "statement_ns": 2777600, + "success": true + }, + { + "mutex_wait_ns": 2650800, + "serialization_ns": 100800, + "serialized_bytes": 1299, + "statement_ns": 2848200, + "success": true + }, + { + "mutex_wait_ns": 2793000, + "serialization_ns": 56900, + "serialized_bytes": 1087, + "statement_ns": 2814800, + "success": true + }, + { + "mutex_wait_ns": 2260900, + "serialization_ns": 30000, + "serialized_bytes": 611, + "statement_ns": 3518500, + "success": true + }, + { + "mutex_wait_ns": 3447000, + "serialization_ns": 62500, + "serialized_bytes": 1303, + "statement_ns": 3077800, + "success": true + }, + { + "mutex_wait_ns": 3067000, + "serialization_ns": 32400, + "serialized_bytes": 611, + "statement_ns": 2726400, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 51400, + "serialized_bytes": 1036, + "statement_ns": 2520900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 52600, + "serialized_bytes": 1075, + "statement_ns": 4191600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 54600, + "serialized_bytes": 1083, + "statement_ns": 4249600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 61500, + "serialized_bytes": 1299, + "statement_ns": 4089900, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 1817700, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=0", + "COMPILER=msvc-1944", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_W32", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "TLS", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 723680900, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 177545200, + 176927000, + 679641000, + 679592300, + 681561200, + 681975100, + 679104500, + 681875300, + 679312900, + 681938000, + 679581600, + 679649000, + 679195400, + 680951300, + 717732300, + 716244600, + 715724300, + 718276400, + 718037200, + 716510700, + 718231200, + 716761100, + 720240600, + 720959300, + 719157600, + 719267400, + 720986000, + 719428300, + 720503800, + 719653600, + 721000200, + 721101400 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 406900, + 12534600, + 24219700, + 71970300, + 533907700, + 28961000, + 463100, + 363400 + ], + "failures": 0, + "in_window_samples": 5, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 406900, + "end_ns": 11527900, + "in_window": false, + "scheduled_ns": null, + "start_ns": 11121000, + "success": true + }, + { + "elapsed_ns": 12534600, + "end_ns": 34221600, + "in_window": true, + "scheduled_ns": null, + "start_ns": 21687000, + "success": true + }, + { + "elapsed_ns": 24219700, + "end_ns": 68641500, + "in_window": true, + "scheduled_ns": null, + "start_ns": 44421800, + "success": true + }, + { + "elapsed_ns": 71970300, + "end_ns": 151145500, + "in_window": true, + "scheduled_ns": null, + "start_ns": 79175200, + "success": true + }, + { + "elapsed_ns": 533907700, + "end_ns": 695205200, + "in_window": true, + "scheduled_ns": null, + "start_ns": 161297500, + "success": true + }, + { + "elapsed_ns": 28961000, + "end_ns": 734637500, + "in_window": true, + "scheduled_ns": null, + "start_ns": 705676500, + "success": true + }, + { + "elapsed_ns": 463100, + "end_ns": 745235900, + "in_window": false, + "scheduled_ns": null, + "start_ns": 744772800, + "success": true + }, + { + "elapsed_ns": 363400, + "end_ns": 755758300, + "in_window": false, + "scheduled_ns": null, + "start_ns": 755394900, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 6318700, + 20354500, + 48895300, + 580986800, + 32930100, + 3552400, + 4142500 + ], + "failures": 0, + "in_window_samples": 5, + "missed_periods": 67, + "samples": [ + { + "elapsed_ns": 6318700, + "end_ns": 27803700, + "in_window": true, + "scheduled_ns": 21485000, + "start_ns": 27803700, + "success": true + }, + { + "elapsed_ns": 20354500, + "end_ns": 51839500, + "in_window": true, + "scheduled_ns": 31485000, + "start_ns": 51839500, + "success": true + }, + { + "elapsed_ns": 48895300, + "end_ns": 110380300, + "in_window": true, + "scheduled_ns": 61485000, + "start_ns": 110380300, + "success": true + }, + { + "elapsed_ns": 580986800, + "end_ns": 692471800, + "in_window": true, + "scheduled_ns": 111485000, + "start_ns": 692471800, + "success": true + }, + { + "elapsed_ns": 32930100, + "end_ns": 734415100, + "in_window": true, + "scheduled_ns": 701485000, + "start_ns": 734415100, + "success": true + }, + { + "elapsed_ns": 3552400, + "end_ns": 745037400, + "in_window": false, + "scheduled_ns": 741485000, + "start_ns": 745037400, + "success": true + }, + { + "elapsed_ns": 4142500, + "end_ns": 755627500, + "in_window": false, + "scheduled_ns": 751485000, + "start_ns": 755627500, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 735209700, + "window_start_ns": 11528800 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 2, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 600, + "serialization_ns": 35900, + "serialized_bytes": 611, + "statement_ns": 3915600, + "success": true + }, + { + "mutex_wait_ns": 137100, + "serialization_ns": 32300, + "serialized_bytes": 613, + "statement_ns": 3143800, + "success": true + }, + { + "mutex_wait_ns": 3146500, + "serialization_ns": 31000, + "serialized_bytes": 611, + "statement_ns": 3941300, + "success": true + }, + { + "mutex_wait_ns": 3908400, + "serialization_ns": 52300, + "serialized_bytes": 613, + "statement_ns": 3100700, + "success": true + }, + { + "mutex_wait_ns": 3047800, + "serialization_ns": 52800, + "serialized_bytes": 1036, + "statement_ns": 3379800, + "success": true + }, + { + "mutex_wait_ns": 3333000, + "serialization_ns": 50600, + "serialized_bytes": 1040, + "statement_ns": 2936200, + "success": true + }, + { + "mutex_wait_ns": 2865100, + "serialization_ns": 55700, + "serialized_bytes": 1075, + "statement_ns": 2729200, + "success": true + }, + { + "mutex_wait_ns": 2668200, + "serialization_ns": 53900, + "serialized_bytes": 1079, + "statement_ns": 3596400, + "success": true + }, + { + "mutex_wait_ns": 3528600, + "serialization_ns": 66900, + "serialized_bytes": 1083, + "statement_ns": 2843000, + "success": true + }, + { + "mutex_wait_ns": 2799300, + "serialization_ns": 56000, + "serialized_bytes": 1087, + "statement_ns": 3181900, + "success": true + }, + { + "mutex_wait_ns": 3085400, + "serialization_ns": 76200, + "serialized_bytes": 1299, + "statement_ns": 6592100, + "success": true + }, + { + "mutex_wait_ns": 6523100, + "serialization_ns": 61500, + "serialized_bytes": 1303, + "statement_ns": 2670800, + "success": true + }, + { + "mutex_wait_ns": 613800, + "serialization_ns": 32500, + "serialized_bytes": 613, + "statement_ns": 3468200, + "success": true + }, + { + "mutex_wait_ns": 3065400, + "serialization_ns": 29300, + "serialized_bytes": 611, + "statement_ns": 3323300, + "success": true + }, + { + "mutex_wait_ns": 3334600, + "serialization_ns": 32300, + "serialized_bytes": 613, + "statement_ns": 3628200, + "success": true + }, + { + "mutex_wait_ns": 3640300, + "serialization_ns": 31600, + "serialized_bytes": 611, + "statement_ns": 2585900, + "success": true + }, + { + "mutex_wait_ns": 2538600, + "serialization_ns": 48700, + "serialized_bytes": 1040, + "statement_ns": 3086600, + "success": true + }, + { + "mutex_wait_ns": 3045300, + "serialization_ns": 48300, + "serialized_bytes": 1036, + "statement_ns": 3467900, + "success": true + }, + { + "mutex_wait_ns": 3384000, + "serialization_ns": 53900, + "serialized_bytes": 1079, + "statement_ns": 2665200, + "success": true + }, + { + "mutex_wait_ns": 2601600, + "serialization_ns": 50400, + "serialized_bytes": 1075, + "statement_ns": 3423200, + "success": true + }, + { + "mutex_wait_ns": 3372400, + "serialization_ns": 54100, + "serialized_bytes": 1087, + "statement_ns": 3052300, + "success": true + }, + { + "mutex_wait_ns": 3007300, + "serialization_ns": 52900, + "serialized_bytes": 1083, + "statement_ns": 3166400, + "success": true + }, + { + "mutex_wait_ns": 3099400, + "serialization_ns": 59100, + "serialized_bytes": 1303, + "statement_ns": 3913200, + "success": true + }, + { + "mutex_wait_ns": 3851700, + "serialization_ns": 60800, + "serialized_bytes": 1299, + "statement_ns": 3406100, + "success": true + }, + { + "mutex_wait_ns": 2777200, + "serialization_ns": 30800, + "serialized_bytes": 611, + "statement_ns": 4795700, + "success": true + }, + { + "mutex_wait_ns": 4196300, + "serialization_ns": 29900, + "serialized_bytes": 613, + "statement_ns": 3223400, + "success": true + }, + { + "mutex_wait_ns": 3218500, + "serialization_ns": 33500, + "serialized_bytes": 611, + "statement_ns": 3339700, + "success": true + }, + { + "mutex_wait_ns": 3336800, + "serialization_ns": 31800, + "serialized_bytes": 613, + "statement_ns": 4778800, + "success": true + }, + { + "mutex_wait_ns": 4727000, + "serialization_ns": 50400, + "serialized_bytes": 1036, + "statement_ns": 2474100, + "success": true + }, + { + "mutex_wait_ns": 2429600, + "serialization_ns": 48800, + "serialized_bytes": 1040, + "statement_ns": 2489700, + "success": true + }, + { + "mutex_wait_ns": 2404600, + "serialization_ns": 55500, + "serialized_bytes": 1075, + "statement_ns": 2966800, + "success": true + }, + { + "mutex_wait_ns": 2893500, + "serialization_ns": 52800, + "serialized_bytes": 1079, + "statement_ns": 2743700, + "success": true + }, + { + "mutex_wait_ns": 2693800, + "serialization_ns": 53800, + "serialized_bytes": 1083, + "statement_ns": 3630400, + "success": true + }, + { + "mutex_wait_ns": 3587100, + "serialization_ns": 55100, + "serialized_bytes": 1087, + "statement_ns": 3873600, + "success": true + }, + { + "mutex_wait_ns": 3792400, + "serialization_ns": 63100, + "serialized_bytes": 1299, + "statement_ns": 4160500, + "success": true + }, + { + "mutex_wait_ns": 4094000, + "serialization_ns": 60600, + "serialized_bytes": 1303, + "statement_ns": 3156000, + "success": true + }, + { + "mutex_wait_ns": 2057600, + "serialization_ns": 29700, + "serialized_bytes": 613, + "statement_ns": 3240900, + "success": true + }, + { + "mutex_wait_ns": 2852300, + "serialization_ns": 30200, + "serialized_bytes": 613, + "statement_ns": 2928400, + "success": true + }, + { + "mutex_wait_ns": 2924200, + "serialization_ns": 32800, + "serialized_bytes": 613, + "statement_ns": 4321400, + "success": true + }, + { + "mutex_wait_ns": 4320400, + "serialization_ns": 33200, + "serialized_bytes": 613, + "statement_ns": 2463500, + "success": true + }, + { + "mutex_wait_ns": 2411200, + "serialization_ns": 52900, + "serialized_bytes": 1040, + "statement_ns": 2599200, + "success": true + }, + { + "mutex_wait_ns": 2557900, + "serialization_ns": 48900, + "serialized_bytes": 1040, + "statement_ns": 3155200, + "success": true + }, + { + "mutex_wait_ns": 3079000, + "serialization_ns": 54600, + "serialized_bytes": 1079, + "statement_ns": 6179500, + "success": true + }, + { + "mutex_wait_ns": 6115000, + "serialization_ns": 54900, + "serialized_bytes": 1079, + "statement_ns": 4519500, + "success": true + }, + { + "mutex_wait_ns": 4461000, + "serialization_ns": 60700, + "serialized_bytes": 1087, + "statement_ns": 4238100, + "success": true + }, + { + "mutex_wait_ns": 4187600, + "serialization_ns": 59700, + "serialized_bytes": 1087, + "statement_ns": 4316300, + "success": true + }, + { + "mutex_wait_ns": 4215700, + "serialization_ns": 70400, + "serialized_bytes": 1303, + "statement_ns": 4326500, + "success": true + }, + { + "mutex_wait_ns": 4252600, + "serialization_ns": 61800, + "serialized_bytes": 1303, + "statement_ns": 2794900, + "success": true + }, + { + "mutex_wait_ns": 2112700, + "serialization_ns": 29500, + "serialized_bytes": 613, + "statement_ns": 2894800, + "success": true + }, + { + "mutex_wait_ns": 2511500, + "serialization_ns": 28500, + "serialized_bytes": 613, + "statement_ns": 3787700, + "success": true + }, + { + "mutex_wait_ns": 3776300, + "serialization_ns": 34300, + "serialized_bytes": 613, + "statement_ns": 2594400, + "success": true + }, + { + "mutex_wait_ns": 2583900, + "serialization_ns": 34300, + "serialized_bytes": 613, + "statement_ns": 2882200, + "success": true + }, + { + "mutex_wait_ns": 2830400, + "serialization_ns": 50500, + "serialized_bytes": 1040, + "statement_ns": 7508000, + "success": true + }, + { + "mutex_wait_ns": 7467300, + "serialization_ns": 49900, + "serialized_bytes": 1040, + "statement_ns": 2941700, + "success": true + }, + { + "mutex_wait_ns": 2857300, + "serialization_ns": 55000, + "serialized_bytes": 1079, + "statement_ns": 2538900, + "success": true + }, + { + "mutex_wait_ns": 2471800, + "serialization_ns": 52700, + "serialized_bytes": 1079, + "statement_ns": 2484200, + "success": true + }, + { + "mutex_wait_ns": 2434300, + "serialization_ns": 55100, + "serialized_bytes": 1087, + "statement_ns": 2683100, + "success": true + }, + { + "mutex_wait_ns": 2637500, + "serialization_ns": 54600, + "serialized_bytes": 1087, + "statement_ns": 2557300, + "success": true + }, + { + "mutex_wait_ns": 2477300, + "serialization_ns": 63000, + "serialized_bytes": 1303, + "statement_ns": 7910800, + "success": true + }, + { + "mutex_wait_ns": 7852500, + "serialization_ns": 59000, + "serialized_bytes": 1303, + "statement_ns": 2874400, + "success": true + }, + { + "mutex_wait_ns": 2321000, + "serialization_ns": 35000, + "serialized_bytes": 611, + "statement_ns": 2997700, + "success": true + }, + { + "mutex_wait_ns": 2583500, + "serialization_ns": 29800, + "serialized_bytes": 613, + "statement_ns": 4546900, + "success": true + }, + { + "mutex_wait_ns": 4537200, + "serialization_ns": 32900, + "serialized_bytes": 611, + "statement_ns": 2940000, + "success": true + }, + { + "mutex_wait_ns": 2928100, + "serialization_ns": 33400, + "serialized_bytes": 613, + "statement_ns": 3522800, + "success": true + }, + { + "mutex_wait_ns": 3470800, + "serialization_ns": 50800, + "serialized_bytes": 1036, + "statement_ns": 3323100, + "success": true + }, + { + "mutex_wait_ns": 3281000, + "serialization_ns": 49400, + "serialized_bytes": 1040, + "statement_ns": 3023600, + "success": true + }, + { + "mutex_wait_ns": 2933200, + "serialization_ns": 53900, + "serialized_bytes": 1075, + "statement_ns": 4998300, + "success": true + }, + { + "mutex_wait_ns": 4931100, + "serialization_ns": 51100, + "serialized_bytes": 1079, + "statement_ns": 4434800, + "success": true + }, + { + "mutex_wait_ns": 4387100, + "serialization_ns": 54100, + "serialized_bytes": 1083, + "statement_ns": 7850600, + "success": true + }, + { + "mutex_wait_ns": 7981900, + "serialization_ns": 50900, + "serialized_bytes": 1087, + "statement_ns": 4109400, + "success": true + }, + { + "mutex_wait_ns": 4032700, + "serialization_ns": 76800, + "serialized_bytes": 1299, + "statement_ns": 3953800, + "success": true + }, + { + "mutex_wait_ns": 3894000, + "serialization_ns": 63700, + "serialized_bytes": 1303, + "statement_ns": 3915800, + "success": true + }, + { + "mutex_wait_ns": 3311200, + "serialization_ns": 36300, + "serialized_bytes": 613, + "statement_ns": 8624500, + "success": true + }, + { + "mutex_wait_ns": 8189000, + "serialization_ns": 29900, + "serialized_bytes": 611, + "statement_ns": 6768000, + "success": true + }, + { + "mutex_wait_ns": 6761700, + "serialization_ns": 38300, + "serialized_bytes": 613, + "statement_ns": 3372000, + "success": true + }, + { + "mutex_wait_ns": 3356900, + "serialization_ns": 38600, + "serialized_bytes": 611, + "statement_ns": 2517900, + "success": true + }, + { + "mutex_wait_ns": 2475300, + "serialization_ns": 51400, + "serialized_bytes": 1040, + "statement_ns": 4208400, + "success": true + }, + { + "mutex_wait_ns": 4175300, + "serialization_ns": 51600, + "serialized_bytes": 1036, + "statement_ns": 2670200, + "success": true + }, + { + "mutex_wait_ns": 2506400, + "serialization_ns": 139500, + "serialized_bytes": 1079, + "statement_ns": 3412200, + "success": true + }, + { + "mutex_wait_ns": 3350700, + "serialization_ns": 53300, + "serialized_bytes": 1075, + "statement_ns": 3481600, + "success": true + }, + { + "mutex_wait_ns": 3214000, + "serialization_ns": 270900, + "serialized_bytes": 1087, + "statement_ns": 3339900, + "success": true + }, + { + "mutex_wait_ns": 3299700, + "serialization_ns": 55400, + "serialized_bytes": 1083, + "statement_ns": 2862600, + "success": true + }, + { + "mutex_wait_ns": 2783300, + "serialization_ns": 81100, + "serialized_bytes": 1303, + "statement_ns": 4381600, + "success": true + }, + { + "mutex_wait_ns": 4304800, + "serialization_ns": 63100, + "serialized_bytes": 1299, + "statement_ns": 3546400, + "success": true + }, + { + "mutex_wait_ns": 2946000, + "serialization_ns": 37200, + "serialized_bytes": 613, + "statement_ns": 5341500, + "success": true + }, + { + "mutex_wait_ns": 4902900, + "serialization_ns": 31300, + "serialized_bytes": 611, + "statement_ns": 4357200, + "success": true + }, + { + "mutex_wait_ns": 4333500, + "serialization_ns": 43200, + "serialized_bytes": 613, + "statement_ns": 2814000, + "success": true + }, + { + "mutex_wait_ns": 2798300, + "serialization_ns": 35800, + "serialized_bytes": 611, + "statement_ns": 2678300, + "success": true + }, + { + "mutex_wait_ns": 2626400, + "serialization_ns": 53500, + "serialized_bytes": 1040, + "statement_ns": 2744400, + "success": true + }, + { + "mutex_wait_ns": 2700700, + "serialization_ns": 51200, + "serialized_bytes": 1036, + "statement_ns": 2386000, + "success": true + }, + { + "mutex_wait_ns": 2298200, + "serialization_ns": 56900, + "serialized_bytes": 1079, + "statement_ns": 3043700, + "success": true + }, + { + "mutex_wait_ns": 2976100, + "serialization_ns": 52200, + "serialized_bytes": 1075, + "statement_ns": 2444500, + "success": true + }, + { + "mutex_wait_ns": 2399500, + "serialization_ns": 54400, + "serialized_bytes": 1087, + "statement_ns": 2903200, + "success": true + }, + { + "mutex_wait_ns": 2861300, + "serialization_ns": 53500, + "serialized_bytes": 1083, + "statement_ns": 2501700, + "success": true + }, + { + "mutex_wait_ns": 2425800, + "serialization_ns": 63500, + "serialized_bytes": 1303, + "statement_ns": 3144200, + "success": true + }, + { + "mutex_wait_ns": 3098200, + "serialization_ns": 59800, + "serialized_bytes": 1299, + "statement_ns": 2488200, + "success": true + }, + { + "mutex_wait_ns": 1954300, + "serialization_ns": 30000, + "serialized_bytes": 613, + "statement_ns": 4535800, + "success": true + }, + { + "mutex_wait_ns": 4118400, + "serialization_ns": 29200, + "serialized_bytes": 613, + "statement_ns": 3230000, + "success": true + }, + { + "mutex_wait_ns": 3225900, + "serialization_ns": 34500, + "serialized_bytes": 613, + "statement_ns": 3196800, + "success": true + }, + { + "mutex_wait_ns": 3196000, + "serialization_ns": 33100, + "serialized_bytes": 613, + "statement_ns": 2532600, + "success": true + }, + { + "mutex_wait_ns": 2487600, + "serialization_ns": 50500, + "serialized_bytes": 1040, + "statement_ns": 3010700, + "success": true + }, + { + "mutex_wait_ns": 2973000, + "serialization_ns": 48600, + "serialized_bytes": 1040, + "statement_ns": 3205300, + "success": true + }, + { + "mutex_wait_ns": 3125300, + "serialization_ns": 55100, + "serialized_bytes": 1079, + "statement_ns": 3693200, + "success": true + }, + { + "mutex_wait_ns": 3632100, + "serialization_ns": 51600, + "serialized_bytes": 1079, + "statement_ns": 3057800, + "success": true + }, + { + "mutex_wait_ns": 3007900, + "serialization_ns": 54700, + "serialized_bytes": 1087, + "statement_ns": 2644700, + "success": true + }, + { + "mutex_wait_ns": 2606600, + "serialization_ns": 53900, + "serialized_bytes": 1087, + "statement_ns": 2448700, + "success": true + }, + { + "mutex_wait_ns": 2374400, + "serialization_ns": 64100, + "serialized_bytes": 1303, + "statement_ns": 3759200, + "success": true + }, + { + "mutex_wait_ns": 3699400, + "serialization_ns": 60200, + "serialized_bytes": 1303, + "statement_ns": 2553200, + "success": true + }, + { + "mutex_wait_ns": 1901900, + "serialization_ns": 35600, + "serialized_bytes": 613, + "statement_ns": 2996100, + "success": true + }, + { + "mutex_wait_ns": 2614400, + "serialization_ns": 28900, + "serialized_bytes": 613, + "statement_ns": 4634000, + "success": true + }, + { + "mutex_wait_ns": 4619500, + "serialization_ns": 39600, + "serialized_bytes": 613, + "statement_ns": 2728300, + "success": true + }, + { + "mutex_wait_ns": 2724500, + "serialization_ns": 32700, + "serialized_bytes": 613, + "statement_ns": 2314700, + "success": true + }, + { + "mutex_wait_ns": 2266300, + "serialization_ns": 50000, + "serialized_bytes": 1040, + "statement_ns": 2757100, + "success": true + }, + { + "mutex_wait_ns": 2717000, + "serialization_ns": 48100, + "serialized_bytes": 1040, + "statement_ns": 2329900, + "success": true + }, + { + "mutex_wait_ns": 2248500, + "serialization_ns": 54800, + "serialized_bytes": 1079, + "statement_ns": 2693500, + "success": true + }, + { + "mutex_wait_ns": 2628500, + "serialization_ns": 50800, + "serialized_bytes": 1079, + "statement_ns": 2545200, + "success": true + }, + { + "mutex_wait_ns": 2510800, + "serialization_ns": 52000, + "serialized_bytes": 1087, + "statement_ns": 3185600, + "success": true + }, + { + "mutex_wait_ns": 3161800, + "serialization_ns": 51800, + "serialized_bytes": 1087, + "statement_ns": 2450400, + "success": true + }, + { + "mutex_wait_ns": 2354200, + "serialization_ns": 78900, + "serialized_bytes": 1303, + "statement_ns": 3192200, + "success": true + }, + { + "mutex_wait_ns": 3130600, + "serialization_ns": 59900, + "serialized_bytes": 1303, + "statement_ns": 2460000, + "success": true + }, + { + "mutex_wait_ns": 1871100, + "serialization_ns": 43100, + "serialized_bytes": 613, + "statement_ns": 3186500, + "success": true + }, + { + "mutex_wait_ns": 2782200, + "serialization_ns": 28200, + "serialized_bytes": 613, + "statement_ns": 5310800, + "success": true + }, + { + "mutex_wait_ns": 5289200, + "serialization_ns": 38900, + "serialized_bytes": 613, + "statement_ns": 3501100, + "success": true + }, + { + "mutex_wait_ns": 3493500, + "serialization_ns": 31700, + "serialized_bytes": 613, + "statement_ns": 4173800, + "success": true + }, + { + "mutex_wait_ns": 4114200, + "serialization_ns": 56900, + "serialized_bytes": 1040, + "statement_ns": 3161700, + "success": true + }, + { + "mutex_wait_ns": 3123000, + "serialization_ns": 48500, + "serialized_bytes": 1040, + "statement_ns": 2481300, + "success": true + }, + { + "mutex_wait_ns": 2401600, + "serialization_ns": 54400, + "serialized_bytes": 1079, + "statement_ns": 2896000, + "success": true + }, + { + "mutex_wait_ns": 2827100, + "serialization_ns": 51800, + "serialized_bytes": 1079, + "statement_ns": 4511800, + "success": true + }, + { + "mutex_wait_ns": 4464300, + "serialization_ns": 53600, + "serialized_bytes": 1087, + "statement_ns": 2575400, + "success": true + }, + { + "mutex_wait_ns": 2536200, + "serialization_ns": 55300, + "serialized_bytes": 1087, + "statement_ns": 2793600, + "success": true + }, + { + "mutex_wait_ns": 2704000, + "serialization_ns": 63700, + "serialized_bytes": 1303, + "statement_ns": 4230500, + "success": true + }, + { + "mutex_wait_ns": 4166400, + "serialization_ns": 60500, + "serialized_bytes": 1303, + "statement_ns": 2523400, + "success": true + }, + { + "mutex_wait_ns": 1956000, + "serialization_ns": 28400, + "serialized_bytes": 613, + "statement_ns": 3364300, + "success": true + }, + { + "mutex_wait_ns": 2947300, + "serialization_ns": 29100, + "serialized_bytes": 613, + "statement_ns": 5996800, + "success": true + }, + { + "mutex_wait_ns": 5989600, + "serialization_ns": 31200, + "serialized_bytes": 613, + "statement_ns": 6514700, + "success": true + }, + { + "mutex_wait_ns": 6501800, + "serialization_ns": 34800, + "serialized_bytes": 613, + "statement_ns": 2565600, + "success": true + }, + { + "mutex_wait_ns": 2508500, + "serialization_ns": 50900, + "serialized_bytes": 1040, + "statement_ns": 2373200, + "success": true + }, + { + "mutex_wait_ns": 2327400, + "serialization_ns": 49000, + "serialized_bytes": 1040, + "statement_ns": 2455400, + "success": true + }, + { + "mutex_wait_ns": 2368200, + "serialization_ns": 55500, + "serialized_bytes": 1079, + "statement_ns": 3587800, + "success": true + }, + { + "mutex_wait_ns": 3518700, + "serialization_ns": 52500, + "serialized_bytes": 1079, + "statement_ns": 2928800, + "success": true + }, + { + "mutex_wait_ns": 2875900, + "serialization_ns": 54600, + "serialized_bytes": 1087, + "statement_ns": 2563800, + "success": true + }, + { + "mutex_wait_ns": 2521600, + "serialization_ns": 52200, + "serialized_bytes": 1087, + "statement_ns": 3192300, + "success": true + }, + { + "mutex_wait_ns": 3118500, + "serialization_ns": 63100, + "serialized_bytes": 1303, + "statement_ns": 2493800, + "success": true + }, + { + "mutex_wait_ns": 2435200, + "serialization_ns": 58600, + "serialized_bytes": 1303, + "statement_ns": 2563700, + "success": true + }, + { + "mutex_wait_ns": 2052700, + "serialization_ns": 28200, + "serialized_bytes": 611, + "statement_ns": 2727100, + "success": true + }, + { + "mutex_wait_ns": 2346100, + "serialization_ns": 28900, + "serialized_bytes": 611, + "statement_ns": 4113000, + "success": true + }, + { + "mutex_wait_ns": 4102300, + "serialization_ns": 33500, + "serialized_bytes": 611, + "statement_ns": 3696100, + "success": true + }, + { + "mutex_wait_ns": 3686300, + "serialization_ns": 31400, + "serialized_bytes": 611, + "statement_ns": 2820200, + "success": true + }, + { + "mutex_wait_ns": 2776600, + "serialization_ns": 48900, + "serialized_bytes": 1036, + "statement_ns": 3126500, + "success": true + }, + { + "mutex_wait_ns": 3087300, + "serialization_ns": 47800, + "serialized_bytes": 1036, + "statement_ns": 2766600, + "success": true + }, + { + "mutex_wait_ns": 2681400, + "serialization_ns": 55300, + "serialized_bytes": 1075, + "statement_ns": 2332700, + "success": true + }, + { + "mutex_wait_ns": 2267700, + "serialization_ns": 50100, + "serialized_bytes": 1075, + "statement_ns": 2397600, + "success": true + }, + { + "mutex_wait_ns": 2353800, + "serialization_ns": 51500, + "serialized_bytes": 1083, + "statement_ns": 2851700, + "success": true + }, + { + "mutex_wait_ns": 2810100, + "serialization_ns": 53100, + "serialized_bytes": 1083, + "statement_ns": 3092500, + "success": true + }, + { + "mutex_wait_ns": 3026100, + "serialization_ns": 59500, + "serialized_bytes": 1299, + "statement_ns": 2805300, + "success": true + }, + { + "mutex_wait_ns": 2745000, + "serialization_ns": 59500, + "serialized_bytes": 1299, + "statement_ns": 3144600, + "success": true + }, + { + "mutex_wait_ns": 2637500, + "serialization_ns": 28400, + "serialized_bytes": 613, + "statement_ns": 2661900, + "success": true + }, + { + "mutex_wait_ns": 2296000, + "serialization_ns": 28100, + "serialized_bytes": 613, + "statement_ns": 2959400, + "success": true + }, + { + "mutex_wait_ns": 2953200, + "serialization_ns": 31100, + "serialized_bytes": 613, + "statement_ns": 2952300, + "success": true + }, + { + "mutex_wait_ns": 2946600, + "serialization_ns": 32100, + "serialized_bytes": 613, + "statement_ns": 2716600, + "success": true + }, + { + "mutex_wait_ns": 2673600, + "serialization_ns": 59800, + "serialized_bytes": 1040, + "statement_ns": 2989000, + "success": true + }, + { + "mutex_wait_ns": 2964100, + "serialization_ns": 47800, + "serialized_bytes": 1040, + "statement_ns": 5434300, + "success": true + }, + { + "mutex_wait_ns": 5367800, + "serialization_ns": 51500, + "serialized_bytes": 1079, + "statement_ns": 4289900, + "success": true + }, + { + "mutex_wait_ns": 4228700, + "serialization_ns": 52800, + "serialized_bytes": 1079, + "statement_ns": 3087100, + "success": true + }, + { + "mutex_wait_ns": 3039300, + "serialization_ns": 53900, + "serialized_bytes": 1087, + "statement_ns": 4732300, + "success": true + }, + { + "mutex_wait_ns": 4687500, + "serialization_ns": 53700, + "serialized_bytes": 1087, + "statement_ns": 4256400, + "success": true + }, + { + "mutex_wait_ns": 4186600, + "serialization_ns": 59400, + "serialized_bytes": 1303, + "statement_ns": 5725700, + "success": true + }, + { + "mutex_wait_ns": 5669500, + "serialization_ns": 59500, + "serialized_bytes": 1303, + "statement_ns": 3087300, + "success": true + }, + { + "mutex_wait_ns": 353300, + "serialization_ns": 36900, + "serialized_bytes": 611, + "statement_ns": 4249200, + "success": true + }, + { + "mutex_wait_ns": 3739900, + "serialization_ns": 31000, + "serialized_bytes": 611, + "statement_ns": 4510900, + "success": true + }, + { + "mutex_wait_ns": 4509000, + "serialization_ns": 31000, + "serialized_bytes": 611, + "statement_ns": 2495000, + "success": true + }, + { + "mutex_wait_ns": 2486700, + "serialization_ns": 32100, + "serialized_bytes": 611, + "statement_ns": 2321400, + "success": true + }, + { + "mutex_wait_ns": 2278500, + "serialization_ns": 48800, + "serialized_bytes": 1036, + "statement_ns": 2629900, + "success": true + }, + { + "mutex_wait_ns": 2589600, + "serialization_ns": 51200, + "serialized_bytes": 1036, + "statement_ns": 2850600, + "success": true + }, + { + "mutex_wait_ns": 2787300, + "serialization_ns": 50100, + "serialized_bytes": 1075, + "statement_ns": 5327400, + "success": true + }, + { + "mutex_wait_ns": 5271000, + "serialization_ns": 50900, + "serialized_bytes": 1075, + "statement_ns": 3588600, + "success": true + }, + { + "mutex_wait_ns": 3553300, + "serialization_ns": 51800, + "serialized_bytes": 1083, + "statement_ns": 2682200, + "success": true + }, + { + "mutex_wait_ns": 2643900, + "serialization_ns": 52600, + "serialized_bytes": 1083, + "statement_ns": 2648300, + "success": true + }, + { + "mutex_wait_ns": 2556500, + "serialization_ns": 79800, + "serialized_bytes": 1299, + "statement_ns": 3188400, + "success": true + }, + { + "mutex_wait_ns": 3125900, + "serialization_ns": 60600, + "serialized_bytes": 1299, + "statement_ns": 3882700, + "success": true + }, + { + "mutex_wait_ns": 605400, + "serialization_ns": 28800, + "serialized_bytes": 613, + "statement_ns": 3135500, + "success": true + }, + { + "mutex_wait_ns": 2607300, + "serialization_ns": 77800, + "serialized_bytes": 613, + "statement_ns": 3158900, + "success": true + }, + { + "mutex_wait_ns": 3148500, + "serialization_ns": 33900, + "serialized_bytes": 613, + "statement_ns": 2575300, + "success": true + }, + { + "mutex_wait_ns": 2565900, + "serialization_ns": 32100, + "serialized_bytes": 613, + "statement_ns": 2350100, + "success": true + }, + { + "mutex_wait_ns": 2307100, + "serialization_ns": 46900, + "serialized_bytes": 1040, + "statement_ns": 3139600, + "success": true + }, + { + "mutex_wait_ns": 3098500, + "serialization_ns": 48000, + "serialized_bytes": 1040, + "statement_ns": 3512300, + "success": true + }, + { + "mutex_wait_ns": 3451600, + "serialization_ns": 51500, + "serialized_bytes": 1079, + "statement_ns": 2911100, + "success": true + }, + { + "mutex_wait_ns": 2870200, + "serialization_ns": 50600, + "serialized_bytes": 1079, + "statement_ns": 2938800, + "success": true + }, + { + "mutex_wait_ns": 2916400, + "serialization_ns": 53600, + "serialized_bytes": 1087, + "statement_ns": 3551500, + "success": true + }, + { + "mutex_wait_ns": 3520700, + "serialization_ns": 54000, + "serialized_bytes": 1087, + "statement_ns": 3220700, + "success": true + }, + { + "mutex_wait_ns": 3162300, + "serialization_ns": 60400, + "serialized_bytes": 1303, + "statement_ns": 3428000, + "success": true + }, + { + "mutex_wait_ns": 3367400, + "serialization_ns": 60600, + "serialized_bytes": 1303, + "statement_ns": 4652700, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 1794300, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=0", + "COMPILER=msvc-1944", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_W32", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "TLS", + "wall_budget_exceeded": false + } + ], + "not_run": { + "disk_flush_count": "not observed", + "gui_android": "outside harness", + "production_performance": "synthetic test-only harness", + "queue_wait": "no writer queue exists", + "sqlite_busy_wait_separate": "included in statement elapsed" + }, + "profile": "debug", + "runtime": "multi_thread", + "schema": 1, + "status": "PASS", + "timer_network_positive_control": { + "reason": "intentional blocking control requires current-thread runtime", + "status": "NOTRUN" + }, + "workers": 2 + }, + "cleanup_uncertain": false + }, + { + "profile": "release", + "workers": 0, + "status": "PASS", + "reason": null, + "report": { + "cases": [ + { + "batch_elapsed_ns": 575286700, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 574648400, + 573992700, + 573843800, + 573714200, + 573595900, + 573354900, + 573209900, + 573087600, + 572950500, + 572824300, + 572709700, + 572584400, + 572443500, + 572317300, + 572181200, + 572062100, + 571937900, + 571798200, + 571637200, + 571509600, + 571400700, + 571290000, + 571162500, + 571038900, + 570928400, + 570817800, + 570670600, + 570693800, + 570557100, + 570315700, + 570088900, + 570013100 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 1635500, + 558049400, + 324400, + 317100 + ], + "failures": 0, + "in_window_samples": 2, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 1635500, + "end_ns": 12820400, + "in_window": true, + "scheduled_ns": null, + "start_ns": 11184900, + "success": true + }, + { + "elapsed_ns": 558049400, + "end_ns": 581037700, + "in_window": true, + "scheduled_ns": null, + "start_ns": 22988300, + "success": true + }, + { + "elapsed_ns": 324400, + "end_ns": 591532200, + "in_window": false, + "scheduled_ns": null, + "start_ns": 591207800, + "success": true + }, + { + "elapsed_ns": 317100, + "end_ns": 601983400, + "in_window": false, + "scheduled_ns": null, + "start_ns": 601666300, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 564598900, + 4884400, + 4991800, + 2009100 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 56, + "samples": [ + { + "elapsed_ns": 564598900, + "end_ns": 581304600, + "in_window": true, + "scheduled_ns": 16705700, + "start_ns": 581304600, + "success": true + }, + { + "elapsed_ns": 4884400, + "end_ns": 591590100, + "in_window": false, + "scheduled_ns": 586705700, + "start_ns": 591590100, + "success": true + }, + { + "elapsed_ns": 4991800, + "end_ns": 601697500, + "in_window": false, + "scheduled_ns": 596705700, + "start_ns": 601697500, + "success": true + }, + { + "elapsed_ns": 2009100, + "end_ns": 608714800, + "in_window": false, + "scheduled_ns": 606705700, + "start_ns": 608714800, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 582025400, + "window_start_ns": 6738700 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 0, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 100, + "serialization_ns": 9500, + "serialized_bytes": 612, + "statement_ns": 3336300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5100, + "serialized_bytes": 612, + "statement_ns": 2758200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 11400, + "serialized_bytes": 1038, + "statement_ns": 3728000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6600, + "serialized_bytes": 1077, + "statement_ns": 3051300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6600, + "serialized_bytes": 1085, + "statement_ns": 2497200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6200, + "serialized_bytes": 1301, + "statement_ns": 2363900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3800, + "serialized_bytes": 612, + "statement_ns": 2904100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4000, + "serialized_bytes": 612, + "statement_ns": 2861600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1038, + "statement_ns": 2349600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1077, + "statement_ns": 3215000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6400, + "serialized_bytes": 1085, + "statement_ns": 3738900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6200, + "serialized_bytes": 1301, + "statement_ns": 3422600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3200, + "serialized_bytes": 610, + "statement_ns": 2672300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4500, + "serialized_bytes": 610, + "statement_ns": 2360500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5400, + "serialized_bytes": 1034, + "statement_ns": 2389300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5500, + "serialized_bytes": 1073, + "statement_ns": 2374800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5400, + "serialized_bytes": 1081, + "statement_ns": 2372800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1297, + "statement_ns": 2691800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3100, + "serialized_bytes": 610, + "statement_ns": 3103100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4000, + "serialized_bytes": 610, + "statement_ns": 2802400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5100, + "serialized_bytes": 1034, + "statement_ns": 2552600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 5300, + "serialized_bytes": 1073, + "statement_ns": 2699600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6400, + "serialized_bytes": 1081, + "statement_ns": 2442800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6600, + "serialized_bytes": 1297, + "statement_ns": 2958500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3000, + "serialized_bytes": 610, + "statement_ns": 3783300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4100, + "serialized_bytes": 610, + "statement_ns": 2538400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5000, + "serialized_bytes": 1034, + "statement_ns": 2710200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4900, + "serialized_bytes": 1073, + "statement_ns": 2423800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5500, + "serialized_bytes": 1081, + "statement_ns": 2554500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5600, + "serialized_bytes": 1297, + "statement_ns": 2742400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 2800, + "serialized_bytes": 612, + "statement_ns": 3198700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3900, + "serialized_bytes": 612, + "statement_ns": 2692200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5000, + "serialized_bytes": 1038, + "statement_ns": 2931400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5800, + "serialized_bytes": 1077, + "statement_ns": 2577800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5800, + "serialized_bytes": 1085, + "statement_ns": 3144700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1301, + "statement_ns": 2400800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3100, + "serialized_bytes": 612, + "statement_ns": 3937700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4600, + "serialized_bytes": 612, + "statement_ns": 2888400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5300, + "serialized_bytes": 1038, + "statement_ns": 2490600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4800, + "serialized_bytes": 1077, + "statement_ns": 2482000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1085, + "statement_ns": 2567700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5300, + "serialized_bytes": 1301, + "statement_ns": 2950500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3000, + "serialized_bytes": 612, + "statement_ns": 4154800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4000, + "serialized_bytes": 612, + "statement_ns": 3389900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5000, + "serialized_bytes": 1038, + "statement_ns": 2656800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4900, + "serialized_bytes": 1077, + "statement_ns": 2274000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5600, + "serialized_bytes": 1085, + "statement_ns": 2361800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1301, + "statement_ns": 2752700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3200, + "serialized_bytes": 610, + "statement_ns": 3036900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3800, + "serialized_bytes": 610, + "statement_ns": 2415400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4700, + "serialized_bytes": 1034, + "statement_ns": 2385000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5300, + "serialized_bytes": 1073, + "statement_ns": 2197300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1081, + "statement_ns": 2745200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1297, + "statement_ns": 3017400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 2900, + "serialized_bytes": 612, + "statement_ns": 4007400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3800, + "serialized_bytes": 612, + "statement_ns": 2706900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5100, + "serialized_bytes": 1038, + "statement_ns": 3244000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4900, + "serialized_bytes": 1077, + "statement_ns": 2325600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5800, + "serialized_bytes": 1085, + "statement_ns": 2560800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1301, + "statement_ns": 2706400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3300, + "serialized_bytes": 612, + "statement_ns": 3391800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4500, + "serialized_bytes": 612, + "statement_ns": 4647800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1038, + "statement_ns": 2648200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6500, + "serialized_bytes": 1077, + "statement_ns": 2703300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1085, + "statement_ns": 3516300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1301, + "statement_ns": 2788600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3700, + "serialized_bytes": 612, + "statement_ns": 2703900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3600, + "serialized_bytes": 612, + "statement_ns": 2747600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1038, + "statement_ns": 2921900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1077, + "statement_ns": 2769800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6400, + "serialized_bytes": 1085, + "statement_ns": 2707800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6900, + "serialized_bytes": 1301, + "statement_ns": 2509000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3500, + "serialized_bytes": 612, + "statement_ns": 2897500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3700, + "serialized_bytes": 612, + "statement_ns": 2622300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1038, + "statement_ns": 2975900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6700, + "serialized_bytes": 1077, + "statement_ns": 2360100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7500, + "serialized_bytes": 1085, + "statement_ns": 3622900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6800, + "serialized_bytes": 1301, + "statement_ns": 2890800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3600, + "serialized_bytes": 612, + "statement_ns": 3539000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6400, + "serialized_bytes": 612, + "statement_ns": 2567600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5200, + "serialized_bytes": 1038, + "statement_ns": 2669900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1077, + "statement_ns": 3152800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6500, + "serialized_bytes": 1085, + "statement_ns": 4066500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6000, + "serialized_bytes": 1301, + "statement_ns": 2780500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4300, + "serialized_bytes": 612, + "statement_ns": 4082500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 612, + "statement_ns": 2782800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 12300, + "serialized_bytes": 1038, + "statement_ns": 2817700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7200, + "serialized_bytes": 1077, + "statement_ns": 2323200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7000, + "serialized_bytes": 1085, + "statement_ns": 2785900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7200, + "serialized_bytes": 1301, + "statement_ns": 4456200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3400, + "serialized_bytes": 612, + "statement_ns": 5216100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4700, + "serialized_bytes": 612, + "statement_ns": 2748700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 1038, + "statement_ns": 3578000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1077, + "statement_ns": 2504100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1085, + "statement_ns": 2895500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6800, + "serialized_bytes": 1301, + "statement_ns": 7621600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3200, + "serialized_bytes": 612, + "statement_ns": 3866400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4000, + "serialized_bytes": 612, + "statement_ns": 2907300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5100, + "serialized_bytes": 1038, + "statement_ns": 2624800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1077, + "statement_ns": 4469100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1085, + "statement_ns": 3077200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1301, + "statement_ns": 3015100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3800, + "serialized_bytes": 612, + "statement_ns": 3376800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 612, + "statement_ns": 3619100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1038, + "statement_ns": 2435900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1077, + "statement_ns": 2384400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1085, + "statement_ns": 2287500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6200, + "serialized_bytes": 1301, + "statement_ns": 2713400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3500, + "serialized_bytes": 612, + "statement_ns": 2526800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4000, + "serialized_bytes": 612, + "statement_ns": 2281100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4900, + "serialized_bytes": 1038, + "statement_ns": 2602000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4900, + "serialized_bytes": 1077, + "statement_ns": 2206300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1085, + "statement_ns": 2459200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1301, + "statement_ns": 2516500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3500, + "serialized_bytes": 612, + "statement_ns": 4093200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4100, + "serialized_bytes": 612, + "statement_ns": 2642400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4900, + "serialized_bytes": 1038, + "statement_ns": 2500600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5400, + "serialized_bytes": 1077, + "statement_ns": 2501400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1085, + "statement_ns": 2500100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5300, + "serialized_bytes": 1301, + "statement_ns": 2364900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3300, + "serialized_bytes": 612, + "statement_ns": 2909100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4400, + "serialized_bytes": 612, + "statement_ns": 2646300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4800, + "serialized_bytes": 1038, + "statement_ns": 2503800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1077, + "statement_ns": 2819300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7000, + "serialized_bytes": 1085, + "statement_ns": 5353800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6600, + "serialized_bytes": 1301, + "statement_ns": 2426300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3400, + "serialized_bytes": 610, + "statement_ns": 2828700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4100, + "serialized_bytes": 610, + "statement_ns": 2811500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5100, + "serialized_bytes": 1034, + "statement_ns": 2319700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1073, + "statement_ns": 2490200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1081, + "statement_ns": 2662800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6200, + "serialized_bytes": 1297, + "statement_ns": 2350900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3100, + "serialized_bytes": 610, + "statement_ns": 3083600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3800, + "serialized_bytes": 610, + "statement_ns": 2281200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5100, + "serialized_bytes": 1034, + "statement_ns": 2532400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1073, + "statement_ns": 3802500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 9300, + "serialized_bytes": 1081, + "statement_ns": 2477000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6500, + "serialized_bytes": 1297, + "statement_ns": 2754400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 2900, + "serialized_bytes": 610, + "statement_ns": 2855400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4400, + "serialized_bytes": 610, + "statement_ns": 3407500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5900, + "serialized_bytes": 1034, + "statement_ns": 2446600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1073, + "statement_ns": 2592800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7000, + "serialized_bytes": 1081, + "statement_ns": 2540700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5500, + "serialized_bytes": 1297, + "statement_ns": 2548600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3300, + "serialized_bytes": 612, + "statement_ns": 3946000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4100, + "serialized_bytes": 612, + "statement_ns": 2543100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6700, + "serialized_bytes": 1038, + "statement_ns": 2552400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5300, + "serialized_bytes": 1077, + "statement_ns": 2368900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7500, + "serialized_bytes": 1085, + "statement_ns": 2528100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6900, + "serialized_bytes": 1301, + "statement_ns": 2845900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3600, + "serialized_bytes": 612, + "statement_ns": 2930500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4200, + "serialized_bytes": 612, + "statement_ns": 2895200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5400, + "serialized_bytes": 1038, + "statement_ns": 2500300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5500, + "serialized_bytes": 1077, + "statement_ns": 2781500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6600, + "serialized_bytes": 1085, + "statement_ns": 4022300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6300, + "serialized_bytes": 1301, + "statement_ns": 3166800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3300, + "serialized_bytes": 612, + "statement_ns": 3346400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4800, + "serialized_bytes": 612, + "statement_ns": 2700100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5100, + "serialized_bytes": 1038, + "statement_ns": 2561900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6300, + "serialized_bytes": 1077, + "statement_ns": 2828200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6100, + "serialized_bytes": 1085, + "statement_ns": 2587800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1301, + "statement_ns": 3163500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3000, + "serialized_bytes": 612, + "statement_ns": 4592900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4200, + "serialized_bytes": 612, + "statement_ns": 2654300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5800, + "serialized_bytes": 1038, + "statement_ns": 2672300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5500, + "serialized_bytes": 1077, + "statement_ns": 3639200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1085, + "statement_ns": 2746200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1301, + "statement_ns": 2571600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3700, + "serialized_bytes": 612, + "statement_ns": 2595200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4400, + "serialized_bytes": 612, + "statement_ns": 2595900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5300, + "serialized_bytes": 1038, + "statement_ns": 2532600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1077, + "statement_ns": 2646100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6200, + "serialized_bytes": 1085, + "statement_ns": 2568000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1301, + "statement_ns": 2424300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3700, + "serialized_bytes": 610, + "statement_ns": 3661800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3800, + "serialized_bytes": 610, + "statement_ns": 2627700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 1034, + "statement_ns": 2673900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5000, + "serialized_bytes": 1073, + "statement_ns": 3129200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1081, + "statement_ns": 2547600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1297, + "statement_ns": 2532700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 2900, + "serialized_bytes": 610, + "statement_ns": 2607900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4000, + "serialized_bytes": 610, + "statement_ns": 2621400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4900, + "serialized_bytes": 1034, + "statement_ns": 2617300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5400, + "serialized_bytes": 1073, + "statement_ns": 2841900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1081, + "statement_ns": 3250400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5100, + "serialized_bytes": 1297, + "statement_ns": 2791100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3200, + "serialized_bytes": 610, + "statement_ns": 4366900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3800, + "serialized_bytes": 610, + "statement_ns": 2725900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5400, + "serialized_bytes": 1034, + "statement_ns": 2774700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5100, + "serialized_bytes": 1073, + "statement_ns": 2479900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1081, + "statement_ns": 2180900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1297, + "statement_ns": 2661500, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 1461100, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=0", + "COMPILER=msvc-1944", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_W32", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "HTTP", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 600545200, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 600021100, + 599788300, + 599669900, + 599561500, + 599458400, + 599342400, + 599226500, + 599121800, + 599017500, + 598893300, + 598750500, + 598625800, + 598498600, + 598393600, + 598290400, + 598182900, + 598060500, + 597948800, + 597831700, + 597697600, + 597566300, + 597456100, + 597336700, + 597227900, + 597120400, + 597010500, + 596881000, + 596922900, + 596758800, + 596653000, + 596451500, + 596404900 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 592736300, + 379700, + 712800 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 592736300, + "end_ns": 604862200, + "in_window": true, + "scheduled_ns": null, + "start_ns": 12125900, + "success": true + }, + { + "elapsed_ns": 379700, + "end_ns": 615642800, + "in_window": false, + "scheduled_ns": null, + "start_ns": 615263100, + "success": true + }, + { + "elapsed_ns": 712800, + "end_ns": 626485800, + "in_window": false, + "scheduled_ns": null, + "start_ns": 625773000, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 590022800, + 10977400 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 60, + "samples": [ + { + "elapsed_ns": 590022800, + "end_ns": 605156500, + "in_window": true, + "scheduled_ns": 15133700, + "start_ns": 605156500, + "success": true + }, + { + "elapsed_ns": 10977400, + "end_ns": 626111100, + "in_window": false, + "scheduled_ns": 615133700, + "start_ns": 626111100, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 605692000, + "window_start_ns": 5146800 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 1, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 0, + "serialization_ns": 4100, + "serialized_bytes": 612, + "statement_ns": 3050300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5100, + "serialized_bytes": 612, + "statement_ns": 3282200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6400, + "serialized_bytes": 1038, + "statement_ns": 3895800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 8500, + "serialized_bytes": 1077, + "statement_ns": 2987800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 10100, + "serialized_bytes": 1085, + "statement_ns": 2452700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6300, + "serialized_bytes": 1301, + "statement_ns": 2765500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3600, + "serialized_bytes": 610, + "statement_ns": 2762700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3600, + "serialized_bytes": 610, + "statement_ns": 2609500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1034, + "statement_ns": 2566900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1073, + "statement_ns": 5557800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6400, + "serialized_bytes": 1081, + "statement_ns": 2370200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6600, + "serialized_bytes": 1297, + "statement_ns": 4231700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3400, + "serialized_bytes": 610, + "statement_ns": 2855800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3700, + "serialized_bytes": 610, + "statement_ns": 2751800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4900, + "serialized_bytes": 1034, + "statement_ns": 2511600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4800, + "serialized_bytes": 1073, + "statement_ns": 2886500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6000, + "serialized_bytes": 1081, + "statement_ns": 2864900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1297, + "statement_ns": 4447600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3400, + "serialized_bytes": 612, + "statement_ns": 4732800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5000, + "serialized_bytes": 612, + "statement_ns": 2414800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1038, + "statement_ns": 2567700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6100, + "serialized_bytes": 1077, + "statement_ns": 2619200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7000, + "serialized_bytes": 1085, + "statement_ns": 2368400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6900, + "serialized_bytes": 1301, + "statement_ns": 2366100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3100, + "serialized_bytes": 612, + "statement_ns": 2691300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4500, + "serialized_bytes": 612, + "statement_ns": 2847800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5800, + "serialized_bytes": 1038, + "statement_ns": 2748800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1077, + "statement_ns": 3423600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5800, + "serialized_bytes": 1085, + "statement_ns": 3146900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1301, + "statement_ns": 4775100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 2900, + "serialized_bytes": 612, + "statement_ns": 2572500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3900, + "serialized_bytes": 612, + "statement_ns": 3015200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5200, + "serialized_bytes": 1038, + "statement_ns": 3053400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5000, + "serialized_bytes": 1077, + "statement_ns": 2503300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6100, + "serialized_bytes": 1085, + "statement_ns": 2669100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6200, + "serialized_bytes": 1301, + "statement_ns": 3880700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3200, + "serialized_bytes": 612, + "statement_ns": 3149700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3800, + "serialized_bytes": 612, + "statement_ns": 2432500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1038, + "statement_ns": 3071000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5300, + "serialized_bytes": 1077, + "statement_ns": 2988000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5000, + "serialized_bytes": 1085, + "statement_ns": 2438700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1301, + "statement_ns": 2684300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 2900, + "serialized_bytes": 612, + "statement_ns": 3956800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4200, + "serialized_bytes": 612, + "statement_ns": 2547700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5400, + "serialized_bytes": 1038, + "statement_ns": 3049100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6200, + "serialized_bytes": 1077, + "statement_ns": 2451700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6200, + "serialized_bytes": 1085, + "statement_ns": 2502300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6100, + "serialized_bytes": 1301, + "statement_ns": 2438000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3000, + "serialized_bytes": 610, + "statement_ns": 3562300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4000, + "serialized_bytes": 610, + "statement_ns": 2339300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1034, + "statement_ns": 2291500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 5900, + "serialized_bytes": 1073, + "statement_ns": 2491400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1081, + "statement_ns": 3053300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1297, + "statement_ns": 3040700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 2900, + "serialized_bytes": 610, + "statement_ns": 3403300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4000, + "serialized_bytes": 610, + "statement_ns": 2889800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5400, + "serialized_bytes": 1034, + "statement_ns": 3845700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6200, + "serialized_bytes": 1073, + "statement_ns": 2289800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6000, + "serialized_bytes": 1081, + "statement_ns": 2566100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6400, + "serialized_bytes": 1297, + "statement_ns": 2851000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3100, + "serialized_bytes": 610, + "statement_ns": 3720000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4900, + "serialized_bytes": 610, + "statement_ns": 2777300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6300, + "serialized_bytes": 1034, + "statement_ns": 18152000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 10600, + "serialized_bytes": 1073, + "statement_ns": 3070300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7200, + "serialized_bytes": 1081, + "statement_ns": 2715200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1297, + "statement_ns": 2792600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3700, + "serialized_bytes": 612, + "statement_ns": 2740500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4300, + "serialized_bytes": 612, + "statement_ns": 3976700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5600, + "serialized_bytes": 1038, + "statement_ns": 4145200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1077, + "statement_ns": 2338700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5900, + "serialized_bytes": 1085, + "statement_ns": 2343100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5800, + "serialized_bytes": 1301, + "statement_ns": 2690100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3700, + "serialized_bytes": 612, + "statement_ns": 2564200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4300, + "serialized_bytes": 612, + "statement_ns": 2541900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1038, + "statement_ns": 3012200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6800, + "serialized_bytes": 1077, + "statement_ns": 2597900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 1085, + "statement_ns": 2455400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7000, + "serialized_bytes": 1301, + "statement_ns": 5537400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3700, + "serialized_bytes": 610, + "statement_ns": 3249500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3900, + "serialized_bytes": 610, + "statement_ns": 2382800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6500, + "serialized_bytes": 1034, + "statement_ns": 2423100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6800, + "serialized_bytes": 1073, + "statement_ns": 2818400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1081, + "statement_ns": 2847600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1297, + "statement_ns": 2889700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3400, + "serialized_bytes": 612, + "statement_ns": 6610200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5200, + "serialized_bytes": 612, + "statement_ns": 2628400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1038, + "statement_ns": 2708300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6300, + "serialized_bytes": 1077, + "statement_ns": 2837700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1085, + "statement_ns": 2316500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6600, + "serialized_bytes": 1301, + "statement_ns": 4627000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3800, + "serialized_bytes": 612, + "statement_ns": 2665400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4800, + "serialized_bytes": 612, + "statement_ns": 2473600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4900, + "serialized_bytes": 1038, + "statement_ns": 2349200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5500, + "serialized_bytes": 1077, + "statement_ns": 2680800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1085, + "statement_ns": 2445200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5900, + "serialized_bytes": 1301, + "statement_ns": 2787100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 2600, + "serialized_bytes": 612, + "statement_ns": 2578800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3900, + "serialized_bytes": 612, + "statement_ns": 3244100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5300, + "serialized_bytes": 1038, + "statement_ns": 2712900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 1077, + "statement_ns": 3074900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6500, + "serialized_bytes": 1085, + "statement_ns": 2652700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1301, + "statement_ns": 2674000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3000, + "serialized_bytes": 612, + "statement_ns": 3888200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4900, + "serialized_bytes": 612, + "statement_ns": 2394700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1038, + "statement_ns": 2429200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1077, + "statement_ns": 2719600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5500, + "serialized_bytes": 1085, + "statement_ns": 2865200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6800, + "serialized_bytes": 1301, + "statement_ns": 2698600, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 3200, + "serialized_bytes": 612, + "statement_ns": 2784200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3700, + "serialized_bytes": 612, + "statement_ns": 2197400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 1038, + "statement_ns": 3191000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 1077, + "statement_ns": 2634200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1085, + "statement_ns": 3195500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7400, + "serialized_bytes": 1301, + "statement_ns": 2538600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3100, + "serialized_bytes": 612, + "statement_ns": 2963900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4500, + "serialized_bytes": 612, + "statement_ns": 2256900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1038, + "statement_ns": 3859600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6400, + "serialized_bytes": 1077, + "statement_ns": 2697400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7000, + "serialized_bytes": 1085, + "statement_ns": 2760000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6900, + "serialized_bytes": 1301, + "statement_ns": 4953200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3700, + "serialized_bytes": 610, + "statement_ns": 2965300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4100, + "serialized_bytes": 610, + "statement_ns": 2826800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4800, + "serialized_bytes": 1034, + "statement_ns": 4185700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 8500, + "serialized_bytes": 1073, + "statement_ns": 2787300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1081, + "statement_ns": 2632500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6300, + "serialized_bytes": 1297, + "statement_ns": 3196500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 2900, + "serialized_bytes": 610, + "statement_ns": 5631800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5000, + "serialized_bytes": 610, + "statement_ns": 3706300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5400, + "serialized_bytes": 1034, + "statement_ns": 2594300, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 5800, + "serialized_bytes": 1073, + "statement_ns": 2549900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1081, + "statement_ns": 2690100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6300, + "serialized_bytes": 1297, + "statement_ns": 2588600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 2900, + "serialized_bytes": 612, + "statement_ns": 3584900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3900, + "serialized_bytes": 612, + "statement_ns": 2479300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1038, + "statement_ns": 2820000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1077, + "statement_ns": 2409700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5600, + "serialized_bytes": 1085, + "statement_ns": 3151300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1301, + "statement_ns": 4010200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3500, + "serialized_bytes": 612, + "statement_ns": 2652900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3500, + "serialized_bytes": 612, + "statement_ns": 2236200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4300, + "serialized_bytes": 1038, + "statement_ns": 2517700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4900, + "serialized_bytes": 1077, + "statement_ns": 2441800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5300, + "serialized_bytes": 1085, + "statement_ns": 2528000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1301, + "statement_ns": 2442000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 2800, + "serialized_bytes": 612, + "statement_ns": 2828200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3600, + "serialized_bytes": 612, + "statement_ns": 2333500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5100, + "serialized_bytes": 1038, + "statement_ns": 2345200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5100, + "serialized_bytes": 1077, + "statement_ns": 2733000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5400, + "serialized_bytes": 1085, + "statement_ns": 3633900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7300, + "serialized_bytes": 1301, + "statement_ns": 2843100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 2700, + "serialized_bytes": 612, + "statement_ns": 2675900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4400, + "serialized_bytes": 612, + "statement_ns": 2312800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4800, + "serialized_bytes": 1038, + "statement_ns": 2449600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5000, + "serialized_bytes": 1077, + "statement_ns": 2504900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6000, + "serialized_bytes": 1085, + "statement_ns": 2427000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6000, + "serialized_bytes": 1301, + "statement_ns": 3311600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 2800, + "serialized_bytes": 612, + "statement_ns": 2891800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3500, + "serialized_bytes": 612, + "statement_ns": 4050500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4700, + "serialized_bytes": 1038, + "statement_ns": 3141200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1077, + "statement_ns": 2478600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1085, + "statement_ns": 3073700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6200, + "serialized_bytes": 1301, + "statement_ns": 2941700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 2600, + "serialized_bytes": 612, + "statement_ns": 3046200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4000, + "serialized_bytes": 612, + "statement_ns": 2832200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5100, + "serialized_bytes": 1038, + "statement_ns": 2457500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5300, + "serialized_bytes": 1077, + "statement_ns": 5683900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1085, + "statement_ns": 2691900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1301, + "statement_ns": 2370300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3100, + "serialized_bytes": 610, + "statement_ns": 4883200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4800, + "serialized_bytes": 610, + "statement_ns": 2422100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5600, + "serialized_bytes": 1034, + "statement_ns": 2493100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1073, + "statement_ns": 2625100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 5900, + "serialized_bytes": 1081, + "statement_ns": 2814100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5800, + "serialized_bytes": 1297, + "statement_ns": 3234800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3100, + "serialized_bytes": 610, + "statement_ns": 2598400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4600, + "serialized_bytes": 610, + "statement_ns": 2651300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1034, + "statement_ns": 2612900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1073, + "statement_ns": 3309900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1081, + "statement_ns": 2722500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7300, + "serialized_bytes": 1297, + "statement_ns": 2472900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3500, + "serialized_bytes": 612, + "statement_ns": 2839000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4700, + "serialized_bytes": 612, + "statement_ns": 3243100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5900, + "serialized_bytes": 1038, + "statement_ns": 3091200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5800, + "serialized_bytes": 1077, + "statement_ns": 6986900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7300, + "serialized_bytes": 1085, + "statement_ns": 2732200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6800, + "serialized_bytes": 1301, + "statement_ns": 3078400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3200, + "serialized_bytes": 612, + "statement_ns": 2443400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4000, + "serialized_bytes": 612, + "statement_ns": 2557000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1038, + "statement_ns": 2247600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 1077, + "statement_ns": 2670200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1085, + "statement_ns": 2404600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7000, + "serialized_bytes": 1301, + "statement_ns": 2451300, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 1291600, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=0", + "COMPILER=msvc-1944", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_W32", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "HTTP", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 606538400, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 606110800, + 605904300, + 605803100, + 605713800, + 605628200, + 605523400, + 605426500, + 605337200, + 605247700, + 605113900, + 605025800, + 604927500, + 604818800, + 604723900, + 604632200, + 604537300, + 604447800, + 604358900, + 604264100, + 604142000, + 604043200, + 603929400, + 603825900, + 603725900, + 603634300, + 603547300, + 603425500, + 603489600, + 603403100, + 603293600, + 603077600, + 602946200 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 332100, + 595678100, + 347600, + 370700 + ], + "failures": 0, + "in_window_samples": 2, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 332100, + "end_ns": 12505200, + "in_window": true, + "scheduled_ns": null, + "start_ns": 12173100, + "success": true + }, + { + "elapsed_ns": 595678100, + "end_ns": 618337500, + "in_window": true, + "scheduled_ns": null, + "start_ns": 22659400, + "success": true + }, + { + "elapsed_ns": 347600, + "end_ns": 629215400, + "in_window": false, + "scheduled_ns": null, + "start_ns": 628867800, + "success": true + }, + { + "elapsed_ns": 370700, + "end_ns": 639773700, + "in_window": false, + "scheduled_ns": null, + "start_ns": 639403000, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 596110200, + 6734800, + 2859700, + 7584500 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 59, + "samples": [ + { + "elapsed_ns": 596110200, + "end_ns": 618592300, + "in_window": true, + "scheduled_ns": 22482100, + "start_ns": 618592300, + "success": true + }, + { + "elapsed_ns": 6734800, + "end_ns": 629216900, + "in_window": false, + "scheduled_ns": 622482100, + "start_ns": 629216900, + "success": true + }, + { + "elapsed_ns": 2859700, + "end_ns": 635341800, + "in_window": false, + "scheduled_ns": 632482100, + "start_ns": 635341800, + "success": true + }, + { + "elapsed_ns": 7584500, + "end_ns": 650066600, + "in_window": false, + "scheduled_ns": 642482100, + "start_ns": 650066600, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 619032400, + "window_start_ns": 12494000 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 2, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 100, + "serialization_ns": 4600, + "serialized_bytes": 612, + "statement_ns": 4278800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5300, + "serialized_bytes": 612, + "statement_ns": 3142400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1038, + "statement_ns": 2703700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 1077, + "statement_ns": 2952000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1085, + "statement_ns": 3055900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1301, + "statement_ns": 4467400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 2800, + "serialized_bytes": 610, + "statement_ns": 3437100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4300, + "serialized_bytes": 610, + "statement_ns": 2476400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4600, + "serialized_bytes": 1034, + "statement_ns": 2814200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4800, + "serialized_bytes": 1073, + "statement_ns": 4206500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5000, + "serialized_bytes": 1081, + "statement_ns": 4726800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1297, + "statement_ns": 3814000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 2800, + "serialized_bytes": 610, + "statement_ns": 3098700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4500, + "serialized_bytes": 610, + "statement_ns": 2809400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4500, + "serialized_bytes": 1034, + "statement_ns": 2470700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1073, + "statement_ns": 2755500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5800, + "serialized_bytes": 1081, + "statement_ns": 2503000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6200, + "serialized_bytes": 1297, + "statement_ns": 2870900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3200, + "serialized_bytes": 612, + "statement_ns": 2686400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4200, + "serialized_bytes": 612, + "statement_ns": 3792100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5300, + "serialized_bytes": 1038, + "statement_ns": 2544000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1077, + "statement_ns": 2388600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5200, + "serialized_bytes": 1085, + "statement_ns": 2303000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5800, + "serialized_bytes": 1301, + "statement_ns": 2455900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 2900, + "serialized_bytes": 612, + "statement_ns": 4313400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5100, + "serialized_bytes": 612, + "statement_ns": 2462500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 1038, + "statement_ns": 4159900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1077, + "statement_ns": 3167800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5000, + "serialized_bytes": 1085, + "statement_ns": 2453700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 1301, + "statement_ns": 3055700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 2700, + "serialized_bytes": 612, + "statement_ns": 2931100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3600, + "serialized_bytes": 612, + "statement_ns": 2366300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4700, + "serialized_bytes": 1038, + "statement_ns": 2824600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5000, + "serialized_bytes": 1077, + "statement_ns": 2461600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5300, + "serialized_bytes": 1085, + "statement_ns": 2137700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1301, + "statement_ns": 2548000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 2600, + "serialized_bytes": 610, + "statement_ns": 3747700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3500, + "serialized_bytes": 610, + "statement_ns": 2301000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4400, + "serialized_bytes": 1034, + "statement_ns": 2764900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4900, + "serialized_bytes": 1073, + "statement_ns": 2332300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4700, + "serialized_bytes": 1081, + "statement_ns": 2389100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6100, + "serialized_bytes": 1297, + "statement_ns": 4806900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3900, + "serialized_bytes": 610, + "statement_ns": 2754500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4500, + "serialized_bytes": 610, + "statement_ns": 2929800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 41700, + "serialized_bytes": 1034, + "statement_ns": 2572400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1073, + "statement_ns": 3796900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6500, + "serialized_bytes": 1081, + "statement_ns": 3158300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6600, + "serialized_bytes": 1297, + "statement_ns": 3605200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3900, + "serialized_bytes": 612, + "statement_ns": 3233200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4700, + "serialized_bytes": 612, + "statement_ns": 2359300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6100, + "serialized_bytes": 1038, + "statement_ns": 2664500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5600, + "serialized_bytes": 1077, + "statement_ns": 2807100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6400, + "serialized_bytes": 1085, + "statement_ns": 2812000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6800, + "serialized_bytes": 1301, + "statement_ns": 3010800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3600, + "serialized_bytes": 612, + "statement_ns": 2926400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4200, + "serialized_bytes": 612, + "statement_ns": 2563900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1038, + "statement_ns": 3814800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5300, + "serialized_bytes": 1077, + "statement_ns": 2692400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6600, + "serialized_bytes": 1085, + "statement_ns": 2743400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6600, + "serialized_bytes": 1301, + "statement_ns": 2460700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 2700, + "serialized_bytes": 612, + "statement_ns": 3207300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3700, + "serialized_bytes": 612, + "statement_ns": 2603900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4800, + "serialized_bytes": 1038, + "statement_ns": 2769000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5400, + "serialized_bytes": 1077, + "statement_ns": 2941000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5800, + "serialized_bytes": 1085, + "statement_ns": 2683100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4900, + "serialized_bytes": 1301, + "statement_ns": 2952700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 2700, + "serialized_bytes": 612, + "statement_ns": 3051800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4200, + "serialized_bytes": 612, + "statement_ns": 2760000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5100, + "serialized_bytes": 1038, + "statement_ns": 4373600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6000, + "serialized_bytes": 1077, + "statement_ns": 2432000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5300, + "serialized_bytes": 1085, + "statement_ns": 2361900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5800, + "serialized_bytes": 1301, + "statement_ns": 2629600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 2800, + "serialized_bytes": 612, + "statement_ns": 2573600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3400, + "serialized_bytes": 612, + "statement_ns": 2747100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4700, + "serialized_bytes": 1038, + "statement_ns": 2458600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7400, + "serialized_bytes": 1077, + "statement_ns": 2660500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6500, + "serialized_bytes": 1085, + "statement_ns": 2733100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1301, + "statement_ns": 2970800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3000, + "serialized_bytes": 612, + "statement_ns": 4470200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3900, + "serialized_bytes": 612, + "statement_ns": 3049000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4800, + "serialized_bytes": 1038, + "statement_ns": 2529700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5300, + "serialized_bytes": 1077, + "statement_ns": 2535000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5200, + "serialized_bytes": 1085, + "statement_ns": 2460100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4700, + "serialized_bytes": 1301, + "statement_ns": 2564700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 2700, + "serialized_bytes": 612, + "statement_ns": 3305400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4300, + "serialized_bytes": 612, + "statement_ns": 2880400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1038, + "statement_ns": 2890300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1077, + "statement_ns": 2519900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1085, + "statement_ns": 2264600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5800, + "serialized_bytes": 1301, + "statement_ns": 4498800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3400, + "serialized_bytes": 612, + "statement_ns": 3158400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4500, + "serialized_bytes": 612, + "statement_ns": 2450300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4500, + "serialized_bytes": 1038, + "statement_ns": 2532900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7100, + "serialized_bytes": 1077, + "statement_ns": 2737100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1085, + "statement_ns": 5377700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6400, + "serialized_bytes": 1301, + "statement_ns": 3095200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3500, + "serialized_bytes": 612, + "statement_ns": 3343300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3800, + "serialized_bytes": 612, + "statement_ns": 2558900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5000, + "serialized_bytes": 1038, + "statement_ns": 2647000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5300, + "serialized_bytes": 1077, + "statement_ns": 4211400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5500, + "serialized_bytes": 1085, + "statement_ns": 2606400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6100, + "serialized_bytes": 1301, + "statement_ns": 2965700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 2800, + "serialized_bytes": 610, + "statement_ns": 2717700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4100, + "serialized_bytes": 610, + "statement_ns": 2762400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1034, + "statement_ns": 2937300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5300, + "serialized_bytes": 1073, + "statement_ns": 2715900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4500, + "serialized_bytes": 1081, + "statement_ns": 2645500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1297, + "statement_ns": 5140000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3000, + "serialized_bytes": 612, + "statement_ns": 4818600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4400, + "serialized_bytes": 612, + "statement_ns": 2911800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6800, + "serialized_bytes": 1038, + "statement_ns": 3518800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6600, + "serialized_bytes": 1077, + "statement_ns": 3416600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1085, + "statement_ns": 2997400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5300, + "serialized_bytes": 1301, + "statement_ns": 2885300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3200, + "serialized_bytes": 612, + "statement_ns": 2791800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4500, + "serialized_bytes": 612, + "statement_ns": 2788400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5500, + "serialized_bytes": 1038, + "statement_ns": 2580100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1077, + "statement_ns": 2818200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1085, + "statement_ns": 3745600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5400, + "serialized_bytes": 1301, + "statement_ns": 2802400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3600, + "serialized_bytes": 610, + "statement_ns": 3453500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4600, + "serialized_bytes": 610, + "statement_ns": 3041500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5000, + "serialized_bytes": 1034, + "statement_ns": 2440700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4700, + "serialized_bytes": 1073, + "statement_ns": 2494900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4800, + "serialized_bytes": 1081, + "statement_ns": 2773700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5300, + "serialized_bytes": 1297, + "statement_ns": 3056600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3600, + "serialized_bytes": 610, + "statement_ns": 3162500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3700, + "serialized_bytes": 610, + "statement_ns": 2720800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5000, + "serialized_bytes": 1034, + "statement_ns": 3178000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4800, + "serialized_bytes": 1073, + "statement_ns": 4176400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1081, + "statement_ns": 2673700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5300, + "serialized_bytes": 1297, + "statement_ns": 2713100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 2800, + "serialized_bytes": 610, + "statement_ns": 3068000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3400, + "serialized_bytes": 610, + "statement_ns": 2910400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4700, + "serialized_bytes": 1034, + "statement_ns": 3137900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5000, + "serialized_bytes": 1073, + "statement_ns": 3121800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4700, + "serialized_bytes": 1081, + "statement_ns": 2904900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5000, + "serialized_bytes": 1297, + "statement_ns": 2903600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3000, + "serialized_bytes": 610, + "statement_ns": 3111100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3100, + "serialized_bytes": 610, + "statement_ns": 7007900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1034, + "statement_ns": 3139900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6300, + "serialized_bytes": 1073, + "statement_ns": 5532100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6800, + "serialized_bytes": 1081, + "statement_ns": 2816700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5100, + "serialized_bytes": 1297, + "statement_ns": 4621800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3200, + "serialized_bytes": 612, + "statement_ns": 3473100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4000, + "serialized_bytes": 612, + "statement_ns": 2930800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5000, + "serialized_bytes": 1038, + "statement_ns": 3089700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5300, + "serialized_bytes": 1077, + "statement_ns": 4626400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1085, + "statement_ns": 4050500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6400, + "serialized_bytes": 1301, + "statement_ns": 3136500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 2800, + "serialized_bytes": 612, + "statement_ns": 2835800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4000, + "serialized_bytes": 612, + "statement_ns": 2752100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4400, + "serialized_bytes": 1038, + "statement_ns": 2296000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1077, + "statement_ns": 2294000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4800, + "serialized_bytes": 1085, + "statement_ns": 2841300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1301, + "statement_ns": 4069500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3400, + "serialized_bytes": 612, + "statement_ns": 4104300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3900, + "serialized_bytes": 612, + "statement_ns": 3076500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1038, + "statement_ns": 4063700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1077, + "statement_ns": 3040600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1085, + "statement_ns": 2819700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5100, + "serialized_bytes": 1301, + "statement_ns": 3103800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 2800, + "serialized_bytes": 612, + "statement_ns": 3379900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4900, + "serialized_bytes": 612, + "statement_ns": 2470100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5000, + "serialized_bytes": 1038, + "statement_ns": 2556500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6200, + "serialized_bytes": 1077, + "statement_ns": 4720000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5900, + "serialized_bytes": 1085, + "statement_ns": 2611800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5400, + "serialized_bytes": 1301, + "statement_ns": 2803100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3200, + "serialized_bytes": 612, + "statement_ns": 3007000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4100, + "serialized_bytes": 612, + "statement_ns": 2575400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5200, + "serialized_bytes": 1038, + "statement_ns": 2982500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5400, + "serialized_bytes": 1077, + "statement_ns": 3021300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5400, + "serialized_bytes": 1085, + "statement_ns": 4425800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1301, + "statement_ns": 3004400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 2800, + "serialized_bytes": 610, + "statement_ns": 2777200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3900, + "serialized_bytes": 610, + "statement_ns": 3553400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5000, + "serialized_bytes": 1034, + "statement_ns": 3058600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4900, + "serialized_bytes": 1073, + "statement_ns": 2577400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4900, + "serialized_bytes": 1081, + "statement_ns": 2594100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4900, + "serialized_bytes": 1297, + "statement_ns": 2896300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 2800, + "serialized_bytes": 612, + "statement_ns": 2792100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3600, + "serialized_bytes": 612, + "statement_ns": 2653200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5100, + "serialized_bytes": 1038, + "statement_ns": 2801800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6500, + "serialized_bytes": 1077, + "statement_ns": 2820200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1085, + "statement_ns": 2820800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 8100, + "serialized_bytes": 1301, + "statement_ns": 4574300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3500, + "serialized_bytes": 612, + "statement_ns": 5666300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5200, + "serialized_bytes": 612, + "statement_ns": 2646300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6100, + "serialized_bytes": 1038, + "statement_ns": 3432000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1077, + "statement_ns": 2464300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1085, + "statement_ns": 2565200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6600, + "serialized_bytes": 1301, + "statement_ns": 2455600, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 1312200, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=0", + "COMPILER=msvc-1944", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_W32", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "HTTP", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 691054900, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 686527000, + 686391000, + 690284500, + 690021600, + 689887900, + 689763900, + 689646400, + 689526500, + 689397700, + 689282700, + 689164800, + 689024100, + 688898900, + 688776000, + 688658600, + 688522000, + 688404900, + 688293300, + 688177500, + 688036500, + 687921800, + 687780000, + 687667700, + 687558200, + 687445100, + 687334000, + 687221600, + 687109600, + 687158200, + 687292900, + 686717000, + 686613200 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 1240200, + 43256200, + 992900, + 542862400, + 56247400, + 357800, + 332000 + ], + "failures": 0, + "in_window_samples": 5, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 1240200, + "end_ns": 13135600, + "in_window": true, + "scheduled_ns": null, + "start_ns": 11895400, + "success": true + }, + { + "elapsed_ns": 43256200, + "end_ns": 66510700, + "in_window": true, + "scheduled_ns": null, + "start_ns": 23254500, + "success": true + }, + { + "elapsed_ns": 992900, + "end_ns": 77745500, + "in_window": true, + "scheduled_ns": null, + "start_ns": 76752600, + "success": true + }, + { + "elapsed_ns": 542862400, + "end_ns": 630784400, + "in_window": true, + "scheduled_ns": null, + "start_ns": 87922000, + "success": true + }, + { + "elapsed_ns": 56247400, + "end_ns": 697334600, + "in_window": true, + "scheduled_ns": null, + "start_ns": 641087200, + "success": true + }, + { + "elapsed_ns": 357800, + "end_ns": 708068900, + "in_window": false, + "scheduled_ns": null, + "start_ns": 707711100, + "success": true + }, + { + "elapsed_ns": 332000, + "end_ns": 718510400, + "in_window": false, + "scheduled_ns": null, + "start_ns": 718178400, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 57709300, + 553873800, + 60929500, + 1743100, + 2087800 + ], + "failures": 0, + "in_window_samples": 3, + "missed_periods": 66, + "samples": [ + { + "elapsed_ns": 57709300, + "end_ns": 74107900, + "in_window": true, + "scheduled_ns": 16398600, + "start_ns": 74107900, + "success": true + }, + { + "elapsed_ns": 553873800, + "end_ns": 630272400, + "in_window": true, + "scheduled_ns": 76398600, + "start_ns": 630272400, + "success": true + }, + { + "elapsed_ns": 60929500, + "end_ns": 697328100, + "in_window": true, + "scheduled_ns": 636398600, + "start_ns": 697328100, + "success": true + }, + { + "elapsed_ns": 1743100, + "end_ns": 708141700, + "in_window": false, + "scheduled_ns": 706398600, + "start_ns": 708141700, + "success": true + }, + { + "elapsed_ns": 2087800, + "end_ns": 718486400, + "in_window": false, + "scheduled_ns": 716398600, + "start_ns": 718486400, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 697465000, + "window_start_ns": 6410100 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 0, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 100, + "serialization_ns": 4400, + "serialized_bytes": 613, + "statement_ns": 3811000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5900, + "serialized_bytes": 613, + "statement_ns": 2548400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7300, + "serialized_bytes": 1040, + "statement_ns": 2776500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7200, + "serialized_bytes": 1079, + "statement_ns": 2525300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7700, + "serialized_bytes": 1087, + "statement_ns": 4068200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7000, + "serialized_bytes": 1303, + "statement_ns": 5243400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3500, + "serialized_bytes": 611, + "statement_ns": 3818000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4300, + "serialized_bytes": 611, + "statement_ns": 2330800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 1036, + "statement_ns": 2355500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5300, + "serialized_bytes": 1075, + "statement_ns": 2546700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 1083, + "statement_ns": 2971100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5500, + "serialized_bytes": 1299, + "statement_ns": 2757900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3300, + "serialized_bytes": 613, + "statement_ns": 3404200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4800, + "serialized_bytes": 613, + "statement_ns": 2208000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4800, + "serialized_bytes": 1040, + "statement_ns": 2115200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1079, + "statement_ns": 2171000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1087, + "statement_ns": 2677600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5600, + "serialized_bytes": 1303, + "statement_ns": 3662100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3600, + "serialized_bytes": 611, + "statement_ns": 2979500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4700, + "serialized_bytes": 611, + "statement_ns": 2785000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 1036, + "statement_ns": 2527800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5600, + "serialized_bytes": 1075, + "statement_ns": 3915900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6700, + "serialized_bytes": 1083, + "statement_ns": 3254200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6300, + "serialized_bytes": 1299, + "statement_ns": 2920500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3800, + "serialized_bytes": 611, + "statement_ns": 2641000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4000, + "serialized_bytes": 611, + "statement_ns": 2643300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5400, + "serialized_bytes": 1036, + "statement_ns": 2559300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1075, + "statement_ns": 3405500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6300, + "serialized_bytes": 1083, + "statement_ns": 3334700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1299, + "statement_ns": 4674300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3300, + "serialized_bytes": 613, + "statement_ns": 3865900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4200, + "serialized_bytes": 613, + "statement_ns": 3893500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1040, + "statement_ns": 3454700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6500, + "serialized_bytes": 1079, + "statement_ns": 4819000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6300, + "serialized_bytes": 1087, + "statement_ns": 3073400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6400, + "serialized_bytes": 1303, + "statement_ns": 3238000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 2900, + "serialized_bytes": 613, + "statement_ns": 3439100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4600, + "serialized_bytes": 613, + "statement_ns": 2971900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5000, + "serialized_bytes": 1040, + "statement_ns": 3690300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6100, + "serialized_bytes": 1079, + "statement_ns": 2530800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1087, + "statement_ns": 2491700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1303, + "statement_ns": 2966300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3600, + "serialized_bytes": 613, + "statement_ns": 4153500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 613, + "statement_ns": 2343500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5100, + "serialized_bytes": 1040, + "statement_ns": 2777800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5100, + "serialized_bytes": 1079, + "statement_ns": 2433800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6200, + "serialized_bytes": 1087, + "statement_ns": 3039600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5900, + "serialized_bytes": 1303, + "statement_ns": 2674100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3200, + "serialized_bytes": 613, + "statement_ns": 3296200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4400, + "serialized_bytes": 613, + "statement_ns": 2486600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5300, + "serialized_bytes": 1040, + "statement_ns": 2876100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5400, + "serialized_bytes": 1079, + "statement_ns": 2328700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1087, + "statement_ns": 4610300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1303, + "statement_ns": 5019300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3600, + "serialized_bytes": 611, + "statement_ns": 2508000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3900, + "serialized_bytes": 611, + "statement_ns": 2430300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1036, + "statement_ns": 2234100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1075, + "statement_ns": 2341400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1083, + "statement_ns": 2497900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1299, + "statement_ns": 2912300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3100, + "serialized_bytes": 613, + "statement_ns": 2776300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4100, + "serialized_bytes": 613, + "statement_ns": 2360700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4700, + "serialized_bytes": 1040, + "statement_ns": 2759200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1079, + "statement_ns": 2806800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6100, + "serialized_bytes": 1087, + "statement_ns": 3268500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7000, + "serialized_bytes": 1303, + "statement_ns": 2616100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3100, + "serialized_bytes": 613, + "statement_ns": 2614500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4100, + "serialized_bytes": 613, + "statement_ns": 2315200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1040, + "statement_ns": 2885200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5900, + "serialized_bytes": 1079, + "statement_ns": 3628200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7100, + "serialized_bytes": 1087, + "statement_ns": 3181800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6200, + "serialized_bytes": 1303, + "statement_ns": 4333500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4000, + "serialized_bytes": 613, + "statement_ns": 2859500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3700, + "serialized_bytes": 613, + "statement_ns": 5498800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5400, + "serialized_bytes": 1040, + "statement_ns": 2656700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1079, + "statement_ns": 2622800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6200, + "serialized_bytes": 1087, + "statement_ns": 2633800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5300, + "serialized_bytes": 1303, + "statement_ns": 2801800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3000, + "serialized_bytes": 611, + "statement_ns": 2796100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4600, + "serialized_bytes": 611, + "statement_ns": 2282400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4900, + "serialized_bytes": 1036, + "statement_ns": 2271400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1075, + "statement_ns": 2602400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1083, + "statement_ns": 2851100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6600, + "serialized_bytes": 1299, + "statement_ns": 2769400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4200, + "serialized_bytes": 613, + "statement_ns": 3533200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4500, + "serialized_bytes": 613, + "statement_ns": 2537200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4800, + "serialized_bytes": 1040, + "statement_ns": 3327700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1079, + "statement_ns": 2434400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6100, + "serialized_bytes": 1087, + "statement_ns": 4203700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7200, + "serialized_bytes": 1303, + "statement_ns": 4510500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3900, + "serialized_bytes": 611, + "statement_ns": 2947900, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 4400, + "serialized_bytes": 611, + "statement_ns": 3041600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6500, + "serialized_bytes": 1036, + "statement_ns": 3016900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6500, + "serialized_bytes": 1075, + "statement_ns": 3162700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6900, + "serialized_bytes": 1083, + "statement_ns": 2670700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6300, + "serialized_bytes": 1299, + "statement_ns": 2500900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3900, + "serialized_bytes": 613, + "statement_ns": 2888000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4500, + "serialized_bytes": 613, + "statement_ns": 4419600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1040, + "statement_ns": 3081500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6900, + "serialized_bytes": 1079, + "statement_ns": 3091500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6600, + "serialized_bytes": 1087, + "statement_ns": 2911700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6400, + "serialized_bytes": 1303, + "statement_ns": 3111700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4200, + "serialized_bytes": 613, + "statement_ns": 2783000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4000, + "serialized_bytes": 613, + "statement_ns": 2547700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5600, + "serialized_bytes": 1040, + "statement_ns": 4603000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1079, + "statement_ns": 5118900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6700, + "serialized_bytes": 1087, + "statement_ns": 2473500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6500, + "serialized_bytes": 1303, + "statement_ns": 2924100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 2900, + "serialized_bytes": 613, + "statement_ns": 3052800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4100, + "serialized_bytes": 613, + "statement_ns": 2417800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5900, + "serialized_bytes": 1040, + "statement_ns": 2656300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6500, + "serialized_bytes": 1079, + "statement_ns": 3250900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 8300, + "serialized_bytes": 1087, + "statement_ns": 2628000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7600, + "serialized_bytes": 1303, + "statement_ns": 4572600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3800, + "serialized_bytes": 611, + "statement_ns": 2723500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5300, + "serialized_bytes": 611, + "statement_ns": 3056400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1036, + "statement_ns": 3498400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6000, + "serialized_bytes": 1075, + "statement_ns": 2463900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6300, + "serialized_bytes": 1083, + "statement_ns": 2541200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6500, + "serialized_bytes": 1299, + "statement_ns": 2713500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 3800, + "serialized_bytes": 611, + "statement_ns": 2673000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4500, + "serialized_bytes": 611, + "statement_ns": 2648200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5600, + "serialized_bytes": 1036, + "statement_ns": 2689200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6700, + "serialized_bytes": 1075, + "statement_ns": 4088900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7500, + "serialized_bytes": 1083, + "statement_ns": 2980000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6300, + "serialized_bytes": 1299, + "statement_ns": 2868400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4000, + "serialized_bytes": 613, + "statement_ns": 3337400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5400, + "serialized_bytes": 613, + "statement_ns": 2560300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6500, + "serialized_bytes": 1040, + "statement_ns": 3341700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1079, + "statement_ns": 4546800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7100, + "serialized_bytes": 1087, + "statement_ns": 3211700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7300, + "serialized_bytes": 1303, + "statement_ns": 3412700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3700, + "serialized_bytes": 613, + "statement_ns": 3717700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5300, + "serialized_bytes": 613, + "statement_ns": 2872500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6600, + "serialized_bytes": 1040, + "statement_ns": 2725300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6100, + "serialized_bytes": 1079, + "statement_ns": 2927500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7300, + "serialized_bytes": 1087, + "statement_ns": 2551900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7000, + "serialized_bytes": 1303, + "statement_ns": 6694400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3400, + "serialized_bytes": 613, + "statement_ns": 5013700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5000, + "serialized_bytes": 613, + "statement_ns": 4375400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6200, + "serialized_bytes": 1040, + "statement_ns": 2863000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6300, + "serialized_bytes": 1079, + "statement_ns": 2520100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6700, + "serialized_bytes": 1087, + "statement_ns": 2953900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6200, + "serialized_bytes": 1303, + "statement_ns": 2794900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3500, + "serialized_bytes": 611, + "statement_ns": 4420100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3800, + "serialized_bytes": 611, + "statement_ns": 2547000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 1036, + "statement_ns": 3460500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6900, + "serialized_bytes": 1075, + "statement_ns": 4139300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5800, + "serialized_bytes": 1083, + "statement_ns": 5300800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7300, + "serialized_bytes": 1299, + "statement_ns": 3458500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4100, + "serialized_bytes": 613, + "statement_ns": 3194100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4900, + "serialized_bytes": 613, + "statement_ns": 2803200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4800, + "serialized_bytes": 1040, + "statement_ns": 2432600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5200, + "serialized_bytes": 1079, + "statement_ns": 2224100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1087, + "statement_ns": 2615000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6000, + "serialized_bytes": 1303, + "statement_ns": 5658100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3600, + "serialized_bytes": 613, + "statement_ns": 3222300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4400, + "serialized_bytes": 613, + "statement_ns": 3237300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5400, + "serialized_bytes": 1040, + "statement_ns": 3619400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7500, + "serialized_bytes": 1079, + "statement_ns": 2748500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7300, + "serialized_bytes": 1087, + "statement_ns": 4525600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7800, + "serialized_bytes": 1303, + "statement_ns": 3337100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3300, + "serialized_bytes": 613, + "statement_ns": 3204900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4700, + "serialized_bytes": 613, + "statement_ns": 2763300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 8000, + "serialized_bytes": 1040, + "statement_ns": 2909800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6600, + "serialized_bytes": 1079, + "statement_ns": 2814100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6100, + "serialized_bytes": 1087, + "statement_ns": 2530900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5800, + "serialized_bytes": 1303, + "statement_ns": 2758700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 2800, + "serialized_bytes": 611, + "statement_ns": 2893900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4100, + "serialized_bytes": 611, + "statement_ns": 2240300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5300, + "serialized_bytes": 1036, + "statement_ns": 2609000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5300, + "serialized_bytes": 1075, + "statement_ns": 2675500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6200, + "serialized_bytes": 1083, + "statement_ns": 2335200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6400, + "serialized_bytes": 1299, + "statement_ns": 3839200, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 3900, + "serialized_bytes": 613, + "statement_ns": 6316400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 613, + "statement_ns": 5332600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7200, + "serialized_bytes": 1040, + "statement_ns": 3057000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6400, + "serialized_bytes": 1079, + "statement_ns": 2336800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6400, + "serialized_bytes": 1087, + "statement_ns": 3478700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6900, + "serialized_bytes": 1303, + "statement_ns": 4474800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3500, + "serialized_bytes": 613, + "statement_ns": 7422100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 613, + "statement_ns": 2811400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6300, + "serialized_bytes": 1040, + "statement_ns": 2519800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6900, + "serialized_bytes": 1079, + "statement_ns": 2497900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6900, + "serialized_bytes": 1087, + "statement_ns": 2658200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6100, + "serialized_bytes": 1303, + "statement_ns": 3017600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3500, + "serialized_bytes": 613, + "statement_ns": 2786900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4500, + "serialized_bytes": 613, + "statement_ns": 3579000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1040, + "statement_ns": 3503000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6500, + "serialized_bytes": 1079, + "statement_ns": 3137800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6300, + "serialized_bytes": 1087, + "statement_ns": 2957200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5500, + "serialized_bytes": 1303, + "statement_ns": 2993100, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 617000, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=0", + "COMPILER=msvc-1944", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_W32", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "TLS", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 573690800, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 569392100, + 569714000, + 569607100, + 573012800, + 572796300, + 572678700, + 572563600, + 572449900, + 572348000, + 572253900, + 572163400, + 572071300, + 571943300, + 571816600, + 571700000, + 571579000, + 571444700, + 571349200, + 571247000, + 571143700, + 571039500, + 570948100, + 570853200, + 570740500, + 570650600, + 570557400, + 570452800, + 570532900, + 570443200, + 570327300, + 570222300, + 569850100 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 6503300, + 614900, + 517306700, + 8001900, + 609200, + 434600 + ], + "failures": 0, + "in_window_samples": 4, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 6503300, + "end_ns": 30184900, + "in_window": true, + "scheduled_ns": null, + "start_ns": 23681600, + "success": true + }, + { + "elapsed_ns": 614900, + "end_ns": 41383300, + "in_window": true, + "scheduled_ns": null, + "start_ns": 40768400, + "success": true + }, + { + "elapsed_ns": 517306700, + "end_ns": 568815600, + "in_window": true, + "scheduled_ns": null, + "start_ns": 51508900, + "success": true + }, + { + "elapsed_ns": 8001900, + "end_ns": 586926800, + "in_window": true, + "scheduled_ns": null, + "start_ns": 578924900, + "success": true + }, + { + "elapsed_ns": 609200, + "end_ns": 597686900, + "in_window": false, + "scheduled_ns": null, + "start_ns": 597077700, + "success": true + }, + { + "elapsed_ns": 434600, + "end_ns": 608207900, + "in_window": false, + "scheduled_ns": null, + "start_ns": 607773300, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 14311000, + 542976500, + 1329000, + 4943600 + ], + "failures": 0, + "in_window_samples": 2, + "missed_periods": 55, + "samples": [ + { + "elapsed_ns": 14311000, + "end_ns": 37605900, + "in_window": true, + "scheduled_ns": 23294900, + "start_ns": 37605900, + "success": true + }, + { + "elapsed_ns": 542976500, + "end_ns": 586271400, + "in_window": true, + "scheduled_ns": 43294900, + "start_ns": 586271400, + "success": true + }, + { + "elapsed_ns": 1329000, + "end_ns": 594623900, + "in_window": false, + "scheduled_ns": 593294900, + "start_ns": 594623900, + "success": true + }, + { + "elapsed_ns": 4943600, + "end_ns": 608238500, + "in_window": false, + "scheduled_ns": 603294900, + "start_ns": 608238500, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 586991600, + "window_start_ns": 13300800 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 1, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 0, + "serialization_ns": 5000, + "serialized_bytes": 613, + "statement_ns": 3148000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6900, + "serialized_bytes": 613, + "statement_ns": 2554000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7100, + "serialized_bytes": 1040, + "statement_ns": 3605900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7400, + "serialized_bytes": 1079, + "statement_ns": 2542800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7000, + "serialized_bytes": 1087, + "statement_ns": 2347700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6800, + "serialized_bytes": 1303, + "statement_ns": 3308700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3400, + "serialized_bytes": 611, + "statement_ns": 3043000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4800, + "serialized_bytes": 611, + "statement_ns": 2505200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5600, + "serialized_bytes": 1036, + "statement_ns": 2543000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5900, + "serialized_bytes": 1075, + "statement_ns": 2993200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6800, + "serialized_bytes": 1083, + "statement_ns": 2509000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6200, + "serialized_bytes": 1299, + "statement_ns": 2199100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3000, + "serialized_bytes": 613, + "statement_ns": 2711100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3700, + "serialized_bytes": 613, + "statement_ns": 2956900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4700, + "serialized_bytes": 1040, + "statement_ns": 2817900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6200, + "serialized_bytes": 1079, + "statement_ns": 2430200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1087, + "statement_ns": 3001500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5400, + "serialized_bytes": 1303, + "statement_ns": 2600800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3700, + "serialized_bytes": 613, + "statement_ns": 2538900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3700, + "serialized_bytes": 613, + "statement_ns": 2530300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5100, + "serialized_bytes": 1040, + "statement_ns": 3258900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6300, + "serialized_bytes": 1079, + "statement_ns": 2290200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1087, + "statement_ns": 2802600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6500, + "serialized_bytes": 1303, + "statement_ns": 2351100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3300, + "serialized_bytes": 611, + "statement_ns": 3028000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3600, + "serialized_bytes": 611, + "statement_ns": 2434000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5100, + "serialized_bytes": 1036, + "statement_ns": 2490100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1075, + "statement_ns": 2372600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1083, + "statement_ns": 2702300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5500, + "serialized_bytes": 1299, + "statement_ns": 2728800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 2900, + "serialized_bytes": 613, + "statement_ns": 2519200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3900, + "serialized_bytes": 613, + "statement_ns": 2369600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6500, + "serialized_bytes": 1040, + "statement_ns": 2598100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1079, + "statement_ns": 3685300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6400, + "serialized_bytes": 1087, + "statement_ns": 2662300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1303, + "statement_ns": 2728100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3300, + "serialized_bytes": 613, + "statement_ns": 3783600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3900, + "serialized_bytes": 613, + "statement_ns": 2486600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5000, + "serialized_bytes": 1040, + "statement_ns": 2381400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5200, + "serialized_bytes": 1079, + "statement_ns": 3137100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5400, + "serialized_bytes": 1087, + "statement_ns": 2849000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6200, + "serialized_bytes": 1303, + "statement_ns": 2947000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4300, + "serialized_bytes": 613, + "statement_ns": 2820100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4200, + "serialized_bytes": 613, + "statement_ns": 2603700, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 5200, + "serialized_bytes": 1040, + "statement_ns": 2305400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1079, + "statement_ns": 2392200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6400, + "serialized_bytes": 1087, + "statement_ns": 2605400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6100, + "serialized_bytes": 1303, + "statement_ns": 2698100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 2900, + "serialized_bytes": 613, + "statement_ns": 2511300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3600, + "serialized_bytes": 613, + "statement_ns": 3158200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5400, + "serialized_bytes": 1040, + "statement_ns": 2692600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6400, + "serialized_bytes": 1079, + "statement_ns": 2627600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5600, + "serialized_bytes": 1087, + "statement_ns": 3136900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1303, + "statement_ns": 3251000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3200, + "serialized_bytes": 613, + "statement_ns": 2626600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4000, + "serialized_bytes": 613, + "statement_ns": 2353300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4400, + "serialized_bytes": 1040, + "statement_ns": 2574000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5600, + "serialized_bytes": 1079, + "statement_ns": 2355800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5300, + "serialized_bytes": 1087, + "statement_ns": 2177000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5200, + "serialized_bytes": 1303, + "statement_ns": 2346800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3400, + "serialized_bytes": 613, + "statement_ns": 2761100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3400, + "serialized_bytes": 613, + "statement_ns": 2363200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4900, + "serialized_bytes": 1040, + "statement_ns": 2394000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5900, + "serialized_bytes": 1079, + "statement_ns": 2590200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5500, + "serialized_bytes": 1087, + "statement_ns": 3037800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5800, + "serialized_bytes": 1303, + "statement_ns": 2771000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3600, + "serialized_bytes": 611, + "statement_ns": 2698600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4100, + "serialized_bytes": 611, + "statement_ns": 2583100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1036, + "statement_ns": 2467700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 8200, + "serialized_bytes": 1075, + "statement_ns": 3151500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6900, + "serialized_bytes": 1083, + "statement_ns": 2559500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7100, + "serialized_bytes": 1299, + "statement_ns": 3662000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3100, + "serialized_bytes": 613, + "statement_ns": 2766500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3900, + "serialized_bytes": 613, + "statement_ns": 2358000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5400, + "serialized_bytes": 1040, + "statement_ns": 2330100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6500, + "serialized_bytes": 1079, + "statement_ns": 3029700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1087, + "statement_ns": 2957200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1303, + "statement_ns": 2661300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3300, + "serialized_bytes": 613, + "statement_ns": 3141700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3600, + "serialized_bytes": 613, + "statement_ns": 2380100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5000, + "serialized_bytes": 1040, + "statement_ns": 2703800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1079, + "statement_ns": 2289900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1087, + "statement_ns": 2294200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5900, + "serialized_bytes": 1303, + "statement_ns": 2472800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3300, + "serialized_bytes": 613, + "statement_ns": 2834400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3400, + "serialized_bytes": 613, + "statement_ns": 4833500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5200, + "serialized_bytes": 1040, + "statement_ns": 2373400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6400, + "serialized_bytes": 1079, + "statement_ns": 2451500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6200, + "serialized_bytes": 1087, + "statement_ns": 2197600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1303, + "statement_ns": 3660900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3200, + "serialized_bytes": 611, + "statement_ns": 2692800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3500, + "serialized_bytes": 611, + "statement_ns": 3161800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5600, + "serialized_bytes": 1036, + "statement_ns": 2336400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1075, + "statement_ns": 2267700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5600, + "serialized_bytes": 1083, + "statement_ns": 2514300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5400, + "serialized_bytes": 1299, + "statement_ns": 2290200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3000, + "serialized_bytes": 611, + "statement_ns": 2538100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4200, + "serialized_bytes": 611, + "statement_ns": 2931000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4900, + "serialized_bytes": 1036, + "statement_ns": 2432100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6500, + "serialized_bytes": 1075, + "statement_ns": 2550000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6500, + "serialized_bytes": 1083, + "statement_ns": 3000900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6200, + "serialized_bytes": 1299, + "statement_ns": 2544300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3400, + "serialized_bytes": 613, + "statement_ns": 2536500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3800, + "serialized_bytes": 613, + "statement_ns": 2227800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4900, + "serialized_bytes": 1040, + "statement_ns": 2293600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1079, + "statement_ns": 2801600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6800, + "serialized_bytes": 1087, + "statement_ns": 2518300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5300, + "serialized_bytes": 1303, + "statement_ns": 3362400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3200, + "serialized_bytes": 613, + "statement_ns": 2868300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4300, + "serialized_bytes": 613, + "statement_ns": 2326300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4600, + "serialized_bytes": 1040, + "statement_ns": 2802700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1079, + "statement_ns": 2246800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6100, + "serialized_bytes": 1087, + "statement_ns": 2512000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5000, + "serialized_bytes": 1303, + "statement_ns": 2412700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3400, + "serialized_bytes": 613, + "statement_ns": 2701400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4300, + "serialized_bytes": 613, + "statement_ns": 2703500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5200, + "serialized_bytes": 1040, + "statement_ns": 2284400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6900, + "serialized_bytes": 1079, + "statement_ns": 3673100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7600, + "serialized_bytes": 1087, + "statement_ns": 2411300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1303, + "statement_ns": 2467500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3400, + "serialized_bytes": 613, + "statement_ns": 3241300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3700, + "serialized_bytes": 613, + "statement_ns": 2840400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5100, + "serialized_bytes": 1040, + "statement_ns": 2591200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6500, + "serialized_bytes": 1079, + "statement_ns": 3521200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1087, + "statement_ns": 3565600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6500, + "serialized_bytes": 1303, + "statement_ns": 3647600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3300, + "serialized_bytes": 611, + "statement_ns": 3008000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4100, + "serialized_bytes": 611, + "statement_ns": 2760800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1036, + "statement_ns": 2313600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5400, + "serialized_bytes": 1075, + "statement_ns": 2439300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1083, + "statement_ns": 2189700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1299, + "statement_ns": 2519700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3600, + "serialized_bytes": 611, + "statement_ns": 2869800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4300, + "serialized_bytes": 611, + "statement_ns": 2411100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 1036, + "statement_ns": 2677800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1075, + "statement_ns": 2228300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5900, + "serialized_bytes": 1083, + "statement_ns": 2515700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1299, + "statement_ns": 3856700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3300, + "serialized_bytes": 613, + "statement_ns": 3890700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4300, + "serialized_bytes": 613, + "statement_ns": 3027600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5400, + "serialized_bytes": 1040, + "statement_ns": 2580600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6300, + "serialized_bytes": 1079, + "statement_ns": 2680100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6500, + "serialized_bytes": 1087, + "statement_ns": 2571200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7300, + "serialized_bytes": 1303, + "statement_ns": 2714100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3500, + "serialized_bytes": 611, + "statement_ns": 7037000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5800, + "serialized_bytes": 611, + "statement_ns": 2553900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1036, + "statement_ns": 2641000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6400, + "serialized_bytes": 1075, + "statement_ns": 2389000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1083, + "statement_ns": 2602000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6400, + "serialized_bytes": 1299, + "statement_ns": 4549400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3300, + "serialized_bytes": 611, + "statement_ns": 2689900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3900, + "serialized_bytes": 611, + "statement_ns": 4844700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5300, + "serialized_bytes": 1036, + "statement_ns": 3066900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7100, + "serialized_bytes": 1075, + "statement_ns": 2753600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6300, + "serialized_bytes": 1083, + "statement_ns": 2628900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6600, + "serialized_bytes": 1299, + "statement_ns": 2464900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3200, + "serialized_bytes": 613, + "statement_ns": 3458500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3700, + "serialized_bytes": 613, + "statement_ns": 2639400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5400, + "serialized_bytes": 1040, + "statement_ns": 2396100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5400, + "serialized_bytes": 1079, + "statement_ns": 2767200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 1087, + "statement_ns": 3596700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1303, + "statement_ns": 2676500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3400, + "serialized_bytes": 613, + "statement_ns": 2761300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4000, + "serialized_bytes": 613, + "statement_ns": 3006700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5400, + "serialized_bytes": 1040, + "statement_ns": 2277900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1079, + "statement_ns": 5149500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5900, + "serialized_bytes": 1087, + "statement_ns": 4066500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1303, + "statement_ns": 3296900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3200, + "serialized_bytes": 613, + "statement_ns": 2712100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4000, + "serialized_bytes": 613, + "statement_ns": 2511200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4600, + "serialized_bytes": 1040, + "statement_ns": 2574700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5800, + "serialized_bytes": 1079, + "statement_ns": 2486700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5400, + "serialized_bytes": 1087, + "statement_ns": 3753400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6000, + "serialized_bytes": 1303, + "statement_ns": 2780300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3300, + "serialized_bytes": 613, + "statement_ns": 3197200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3400, + "serialized_bytes": 613, + "statement_ns": 3139600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5000, + "serialized_bytes": 1040, + "statement_ns": 2507700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4800, + "serialized_bytes": 1079, + "statement_ns": 2716500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1087, + "statement_ns": 2444000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 1303, + "statement_ns": 2531100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 2900, + "serialized_bytes": 611, + "statement_ns": 2446600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3900, + "serialized_bytes": 611, + "statement_ns": 2106900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4600, + "serialized_bytes": 1036, + "statement_ns": 2604700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1075, + "statement_ns": 3135400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5400, + "serialized_bytes": 1083, + "statement_ns": 3039600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6200, + "serialized_bytes": 1299, + "statement_ns": 2665000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3500, + "serialized_bytes": 613, + "statement_ns": 3650000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4100, + "serialized_bytes": 613, + "statement_ns": 2365300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1040, + "statement_ns": 2431600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6000, + "serialized_bytes": 1079, + "statement_ns": 2698200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7100, + "serialized_bytes": 1087, + "statement_ns": 2540900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6900, + "serialized_bytes": 1303, + "statement_ns": 3512300, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 650300, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=0", + "COMPILER=msvc-1944", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_W32", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "TLS", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 599635400, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 598520600, + 598234700, + 595615700, + 595488900, + 596062400, + 595924400, + 595837800, + 598902600, + 598808500, + 598712800, + 598626800, + 598534100, + 598438000, + 598324700, + 598205500, + 598080700, + 597981300, + 597853700, + 597711200, + 597609900, + 597502100, + 597396400, + 597299300, + 597215700, + 597122900, + 597012700, + 596917900, + 596803500, + 596700200, + 596588200, + 596439300, + 596309600 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 1717200, + 3114900, + 3189800, + 26900800, + 520874400, + 389500, + 329100 + ], + "failures": 0, + "in_window_samples": 5, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 1717200, + "end_ns": 25380500, + "in_window": true, + "scheduled_ns": null, + "start_ns": 23663300, + "success": true + }, + { + "elapsed_ns": 3114900, + "end_ns": 38583400, + "in_window": true, + "scheduled_ns": null, + "start_ns": 35468500, + "success": true + }, + { + "elapsed_ns": 3189800, + "end_ns": 51851900, + "in_window": true, + "scheduled_ns": null, + "start_ns": 48662100, + "success": true + }, + { + "elapsed_ns": 26900800, + "end_ns": 88821400, + "in_window": true, + "scheduled_ns": null, + "start_ns": 61920600, + "success": true + }, + { + "elapsed_ns": 520874400, + "end_ns": 619797000, + "in_window": true, + "scheduled_ns": null, + "start_ns": 98922600, + "success": true + }, + { + "elapsed_ns": 389500, + "end_ns": 630466700, + "in_window": false, + "scheduled_ns": null, + "start_ns": 630077200, + "success": true + }, + { + "elapsed_ns": 329100, + "end_ns": 641016200, + "in_window": false, + "scheduled_ns": null, + "start_ns": 640687100, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 17143700, + 568553600, + 9724200, + 2361400, + 358200 + ], + "failures": 0, + "in_window_samples": 2, + "missed_periods": 57, + "samples": [ + { + "elapsed_ns": 17143700, + "end_ns": 47876700, + "in_window": true, + "scheduled_ns": 30733000, + "start_ns": 47876700, + "success": true + }, + { + "elapsed_ns": 568553600, + "end_ns": 619286600, + "in_window": true, + "scheduled_ns": 50733000, + "start_ns": 619286600, + "success": true + }, + { + "elapsed_ns": 9724200, + "end_ns": 630457200, + "in_window": false, + "scheduled_ns": 620733000, + "start_ns": 630457200, + "success": true + }, + { + "elapsed_ns": 2361400, + "end_ns": 633094400, + "in_window": false, + "scheduled_ns": 630733000, + "start_ns": 633094400, + "success": true + }, + { + "elapsed_ns": 358200, + "end_ns": 641091200, + "in_window": false, + "scheduled_ns": 640733000, + "start_ns": 641091200, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 620385700, + "window_start_ns": 20750300 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 2, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 0, + "serialization_ns": 4400, + "serialized_bytes": 613, + "statement_ns": 3874600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 613, + "statement_ns": 2548400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6700, + "serialized_bytes": 1040, + "statement_ns": 3722600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6700, + "serialized_bytes": 1079, + "statement_ns": 2965500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5900, + "serialized_bytes": 1087, + "statement_ns": 2468100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6900, + "serialized_bytes": 1303, + "statement_ns": 2803900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3600, + "serialized_bytes": 613, + "statement_ns": 2507900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4000, + "serialized_bytes": 613, + "statement_ns": 2665200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4800, + "serialized_bytes": 1040, + "statement_ns": 2813400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1079, + "statement_ns": 3243000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5800, + "serialized_bytes": 1087, + "statement_ns": 3401400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1303, + "statement_ns": 2414400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3400, + "serialized_bytes": 613, + "statement_ns": 2566700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4300, + "serialized_bytes": 613, + "statement_ns": 2560600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1040, + "statement_ns": 2480200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6400, + "serialized_bytes": 1079, + "statement_ns": 2675900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7100, + "serialized_bytes": 1087, + "statement_ns": 3092700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6500, + "serialized_bytes": 1303, + "statement_ns": 3058900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3200, + "serialized_bytes": 611, + "statement_ns": 2850700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3700, + "serialized_bytes": 611, + "statement_ns": 2387000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4900, + "serialized_bytes": 1036, + "statement_ns": 2427400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6200, + "serialized_bytes": 1075, + "statement_ns": 2815500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6000, + "serialized_bytes": 1083, + "statement_ns": 2643900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1299, + "statement_ns": 2724700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 2800, + "serialized_bytes": 611, + "statement_ns": 4880500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5200, + "serialized_bytes": 611, + "statement_ns": 2915800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1036, + "statement_ns": 3186300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 8300, + "serialized_bytes": 1075, + "statement_ns": 2632800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6800, + "serialized_bytes": 1083, + "statement_ns": 2327200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6500, + "serialized_bytes": 1299, + "statement_ns": 2899800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3900, + "serialized_bytes": 611, + "statement_ns": 3287000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3500, + "serialized_bytes": 611, + "statement_ns": 3024800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5500, + "serialized_bytes": 1036, + "statement_ns": 2503300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1075, + "statement_ns": 3292100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6200, + "serialized_bytes": 1083, + "statement_ns": 3019400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6300, + "serialized_bytes": 1299, + "statement_ns": 2989200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3400, + "serialized_bytes": 611, + "statement_ns": 2814900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4900, + "serialized_bytes": 611, + "statement_ns": 2437300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5300, + "serialized_bytes": 1036, + "statement_ns": 2835800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6600, + "serialized_bytes": 1075, + "statement_ns": 2574100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6600, + "serialized_bytes": 1083, + "statement_ns": 2226700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6300, + "serialized_bytes": 1299, + "statement_ns": 2906900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3100, + "serialized_bytes": 613, + "statement_ns": 3883100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4700, + "serialized_bytes": 613, + "statement_ns": 2505600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5300, + "serialized_bytes": 1040, + "statement_ns": 4372200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1079, + "statement_ns": 2606900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5900, + "serialized_bytes": 1087, + "statement_ns": 3912100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1303, + "statement_ns": 3195500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3300, + "serialized_bytes": 613, + "statement_ns": 3329800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3700, + "serialized_bytes": 613, + "statement_ns": 3198600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4600, + "serialized_bytes": 1040, + "statement_ns": 2854300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1079, + "statement_ns": 2728900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1087, + "statement_ns": 2598800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7700, + "serialized_bytes": 1303, + "statement_ns": 3042500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3500, + "serialized_bytes": 611, + "statement_ns": 2580000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4200, + "serialized_bytes": 611, + "statement_ns": 2304200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5800, + "serialized_bytes": 1036, + "statement_ns": 3049100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5900, + "serialized_bytes": 1075, + "statement_ns": 2629400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6600, + "serialized_bytes": 1083, + "statement_ns": 2433700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6600, + "serialized_bytes": 1299, + "statement_ns": 2332900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3300, + "serialized_bytes": 611, + "statement_ns": 2643200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4400, + "serialized_bytes": 611, + "statement_ns": 2438800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5300, + "serialized_bytes": 1036, + "statement_ns": 2742000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1075, + "statement_ns": 3815700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7100, + "serialized_bytes": 1083, + "statement_ns": 2961500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1299, + "statement_ns": 3091700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3600, + "serialized_bytes": 613, + "statement_ns": 3028500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3900, + "serialized_bytes": 613, + "statement_ns": 2493800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4700, + "serialized_bytes": 1040, + "statement_ns": 2762700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5400, + "serialized_bytes": 1079, + "statement_ns": 2486200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1087, + "statement_ns": 2588000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5400, + "serialized_bytes": 1303, + "statement_ns": 2557400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 2900, + "serialized_bytes": 613, + "statement_ns": 2582200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3700, + "serialized_bytes": 613, + "statement_ns": 2452900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4600, + "serialized_bytes": 1040, + "statement_ns": 2835500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5100, + "serialized_bytes": 1079, + "statement_ns": 2671600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5300, + "serialized_bytes": 1087, + "statement_ns": 2773700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5900, + "serialized_bytes": 1303, + "statement_ns": 3026300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3500, + "serialized_bytes": 613, + "statement_ns": 3730600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3500, + "serialized_bytes": 613, + "statement_ns": 3664000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1040, + "statement_ns": 2767400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5600, + "serialized_bytes": 1079, + "statement_ns": 3798800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1087, + "statement_ns": 2812900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1303, + "statement_ns": 2625700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3100, + "serialized_bytes": 613, + "statement_ns": 3156600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 613, + "statement_ns": 2789900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1040, + "statement_ns": 2532400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1079, + "statement_ns": 2274500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1087, + "statement_ns": 2805000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1303, + "statement_ns": 4666400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4600, + "serialized_bytes": 613, + "statement_ns": 3123300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4200, + "serialized_bytes": 613, + "statement_ns": 3083400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5300, + "serialized_bytes": 1040, + "statement_ns": 2503400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5600, + "serialized_bytes": 1079, + "statement_ns": 2853500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 1087, + "statement_ns": 4040100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6300, + "serialized_bytes": 1303, + "statement_ns": 5026100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3600, + "serialized_bytes": 611, + "statement_ns": 3377000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3800, + "serialized_bytes": 611, + "statement_ns": 2230500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5400, + "serialized_bytes": 1036, + "statement_ns": 2705300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6000, + "serialized_bytes": 1075, + "statement_ns": 3180000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6200, + "serialized_bytes": 1083, + "statement_ns": 2727500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6200, + "serialized_bytes": 1299, + "statement_ns": 2643600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3400, + "serialized_bytes": 611, + "statement_ns": 2658500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3800, + "serialized_bytes": 611, + "statement_ns": 2634800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 1036, + "statement_ns": 2558200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6300, + "serialized_bytes": 1075, + "statement_ns": 3338900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7700, + "serialized_bytes": 1083, + "statement_ns": 2507400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6900, + "serialized_bytes": 1299, + "statement_ns": 3083500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3700, + "serialized_bytes": 613, + "statement_ns": 2573600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4400, + "serialized_bytes": 613, + "statement_ns": 4093400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1040, + "statement_ns": 2759000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6700, + "serialized_bytes": 1079, + "statement_ns": 3896500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1087, + "statement_ns": 3403400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6800, + "serialized_bytes": 1303, + "statement_ns": 3208200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3500, + "serialized_bytes": 613, + "statement_ns": 2779300, + "success": true + }, + { + "mutex_wait_ns": 500, + "serialization_ns": 4300, + "serialized_bytes": 613, + "statement_ns": 2333700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 1040, + "statement_ns": 2549400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5900, + "serialized_bytes": 1079, + "statement_ns": 2684100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5000, + "serialized_bytes": 1087, + "statement_ns": 2346900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1303, + "statement_ns": 2952000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3400, + "serialized_bytes": 613, + "statement_ns": 2856000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3900, + "serialized_bytes": 613, + "statement_ns": 3346600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5000, + "serialized_bytes": 1040, + "statement_ns": 2395600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6000, + "serialized_bytes": 1079, + "statement_ns": 2459100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1087, + "statement_ns": 2910600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6600, + "serialized_bytes": 1303, + "statement_ns": 3998100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3400, + "serialized_bytes": 613, + "statement_ns": 2784000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5100, + "serialized_bytes": 613, + "statement_ns": 2980600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1040, + "statement_ns": 3255600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6000, + "serialized_bytes": 1079, + "statement_ns": 3381800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6600, + "serialized_bytes": 1087, + "statement_ns": 2789500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7200, + "serialized_bytes": 1303, + "statement_ns": 2678000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3500, + "serialized_bytes": 613, + "statement_ns": 3034000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3900, + "serialized_bytes": 613, + "statement_ns": 2768100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1040, + "statement_ns": 2868100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7600, + "serialized_bytes": 1079, + "statement_ns": 2914900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 8400, + "serialized_bytes": 1087, + "statement_ns": 2906500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7400, + "serialized_bytes": 1303, + "statement_ns": 2700000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3600, + "serialized_bytes": 613, + "statement_ns": 2842000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5100, + "serialized_bytes": 613, + "statement_ns": 2460900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1040, + "statement_ns": 2905600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7100, + "serialized_bytes": 1079, + "statement_ns": 2743100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6300, + "serialized_bytes": 1087, + "statement_ns": 2705900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7300, + "serialized_bytes": 1303, + "statement_ns": 2523600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3700, + "serialized_bytes": 613, + "statement_ns": 2660300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4300, + "serialized_bytes": 613, + "statement_ns": 2491200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4800, + "serialized_bytes": 1040, + "statement_ns": 2749300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1079, + "statement_ns": 3545700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6500, + "serialized_bytes": 1087, + "statement_ns": 3254000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6700, + "serialized_bytes": 1303, + "statement_ns": 2996300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3400, + "serialized_bytes": 613, + "statement_ns": 3375500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4000, + "serialized_bytes": 613, + "statement_ns": 2862200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5200, + "serialized_bytes": 1040, + "statement_ns": 2925600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6800, + "serialized_bytes": 1079, + "statement_ns": 2559700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1087, + "statement_ns": 2810000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1303, + "statement_ns": 2663200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3800, + "serialized_bytes": 613, + "statement_ns": 3227700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4200, + "serialized_bytes": 613, + "statement_ns": 2531900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5800, + "serialized_bytes": 1040, + "statement_ns": 2558800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6200, + "serialized_bytes": 1079, + "statement_ns": 2309900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1087, + "statement_ns": 2867600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1303, + "statement_ns": 3389200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 2700, + "serialized_bytes": 613, + "statement_ns": 2567300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3400, + "serialized_bytes": 613, + "statement_ns": 3216500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 1040, + "statement_ns": 3383800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1079, + "statement_ns": 2618600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1087, + "statement_ns": 2533700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6200, + "serialized_bytes": 1303, + "statement_ns": 4615400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3300, + "serialized_bytes": 611, + "statement_ns": 2862700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4300, + "serialized_bytes": 611, + "statement_ns": 2490800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4700, + "serialized_bytes": 1036, + "statement_ns": 2456300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5100, + "serialized_bytes": 1075, + "statement_ns": 2497400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6600, + "serialized_bytes": 1083, + "statement_ns": 2526600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5300, + "serialized_bytes": 1299, + "statement_ns": 2647600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3500, + "serialized_bytes": 611, + "statement_ns": 2718800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3700, + "serialized_bytes": 611, + "statement_ns": 2356300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4800, + "serialized_bytes": 1036, + "statement_ns": 2292900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1075, + "statement_ns": 2239000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1083, + "statement_ns": 2515600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1299, + "statement_ns": 2647700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3100, + "serialized_bytes": 613, + "statement_ns": 3007100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4100, + "serialized_bytes": 613, + "statement_ns": 3541100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1040, + "statement_ns": 2873600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5400, + "serialized_bytes": 1079, + "statement_ns": 5861100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1087, + "statement_ns": 3305100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1303, + "statement_ns": 3193900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3400, + "serialized_bytes": 613, + "statement_ns": 3776200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4400, + "serialized_bytes": 613, + "statement_ns": 2575200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1040, + "statement_ns": 2432300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5300, + "serialized_bytes": 1079, + "statement_ns": 2382800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5300, + "serialized_bytes": 1087, + "statement_ns": 2317300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5900, + "serialized_bytes": 1303, + "statement_ns": 2362200, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 550800, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=0", + "COMPILER=msvc-1944", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_W32", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "TLS", + "wall_budget_exceeded": false + } + ], + "not_run": { + "disk_flush_count": "not observed", + "gui_android": "outside harness", + "production_performance": "synthetic test-only harness", + "queue_wait": "no writer queue exists", + "sqlite_busy_wait_separate": "included in statement elapsed" + }, + "profile": "release", + "runtime": "current_thread", + "schema": 1, + "status": "PASS", + "timer_network_positive_control": { + "detector_threshold_ms": 100, + "injected_block_ms": 300, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 290729400, + 382000, + 350000 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 290729400, + "end_ns": 329413100, + "in_window": true, + "scheduled_ns": null, + "start_ns": 38683700, + "success": true + }, + { + "elapsed_ns": 382000, + "end_ns": 339988600, + "in_window": false, + "scheduled_ns": null, + "start_ns": 339606600, + "success": true + }, + { + "elapsed_ns": 350000, + "end_ns": 350721900, + "in_window": false, + "scheduled_ns": null, + "start_ns": 350371900, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 290888000, + 1551300, + 2230100 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 29, + "samples": [ + { + "elapsed_ns": 290888000, + "end_ns": 329355900, + "in_window": true, + "scheduled_ns": 38467900, + "start_ns": 329355900, + "success": true + }, + { + "elapsed_ns": 1551300, + "end_ns": 340019200, + "in_window": false, + "scheduled_ns": 338467900, + "start_ns": 340019200, + "success": true + }, + { + "elapsed_ns": 2230100, + "end_ns": 350698000, + "in_window": false, + "scheduled_ns": 348467900, + "start_ns": 350698000, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 329106900, + "window_start_ns": 28500900 + }, + "status": "PASS" + }, + "workers": 0 + }, + "cleanup_uncertain": false + }, + { + "profile": "release", + "workers": 2, + "status": "PASS", + "reason": null, + "report": { + "cases": [ + { + "batch_elapsed_ns": 573371800, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 567985400, + 566763000, + 569332300, + 568232600, + 569582300, + 568212700, + 569161500, + 568204500, + 569180700, + 568169200, + 569026300, + 568164900, + 569034900, + 568118700, + 568970000, + 568111000, + 568957900, + 568895300, + 568042200, + 568869900, + 568105800, + 568831400, + 567998800, + 568814800, + 568056700, + 567789100, + 567654000, + 567978500, + 568009600, + 567699700, + 567595800, + 570991100 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 562328200, + 375500, + 267600, + 390100 + ], + "failures": 0, + "in_window_samples": 1, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 562328200, + "end_ns": 573322200, + "in_window": true, + "scheduled_ns": null, + "start_ns": 10994000, + "success": true + }, + { + "elapsed_ns": 375500, + "end_ns": 583854600, + "in_window": false, + "scheduled_ns": null, + "start_ns": 583479100, + "success": true + }, + { + "elapsed_ns": 267600, + "end_ns": 594257200, + "in_window": false, + "scheduled_ns": null, + "start_ns": 593989600, + "success": true + }, + { + "elapsed_ns": 390100, + "end_ns": 604797500, + "in_window": false, + "scheduled_ns": null, + "start_ns": 604407400, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 559001000, + 309400, + 4872800, + 10516100, + 6394100 + ], + "failures": 0, + "in_window_samples": 2, + "missed_periods": 56, + "samples": [ + { + "elapsed_ns": 559001000, + "end_ns": 573105100, + "in_window": true, + "scheduled_ns": 14104100, + "start_ns": 573105100, + "success": true + }, + { + "elapsed_ns": 309400, + "end_ns": 574413500, + "in_window": true, + "scheduled_ns": 574104100, + "start_ns": 574413500, + "success": true + }, + { + "elapsed_ns": 4872800, + "end_ns": 588976900, + "in_window": false, + "scheduled_ns": 584104100, + "start_ns": 588976900, + "success": true + }, + { + "elapsed_ns": 10516100, + "end_ns": 604620200, + "in_window": false, + "scheduled_ns": 594104100, + "start_ns": 604620200, + "success": true + }, + { + "elapsed_ns": 6394100, + "end_ns": 620498200, + "in_window": false, + "scheduled_ns": 614104100, + "start_ns": 620498200, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 577502100, + "window_start_ns": 4130300 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 0, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 0, + "serialization_ns": 6600, + "serialized_bytes": 610, + "statement_ns": 3638000, + "success": true + }, + { + "mutex_wait_ns": 3657100, + "serialization_ns": 7100, + "serialized_bytes": 610, + "statement_ns": 3902700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4600, + "serialized_bytes": 610, + "statement_ns": 3169400, + "success": true + }, + { + "mutex_wait_ns": 7102500, + "serialization_ns": 5400, + "serialized_bytes": 610, + "statement_ns": 2695800, + "success": true + }, + { + "mutex_wait_ns": 2698400, + "serialization_ns": 7500, + "serialized_bytes": 1034, + "statement_ns": 3963300, + "success": true + }, + { + "mutex_wait_ns": 3977100, + "serialization_ns": 6100, + "serialized_bytes": 1034, + "statement_ns": 3090600, + "success": true + }, + { + "mutex_wait_ns": 3093900, + "serialization_ns": 5800, + "serialized_bytes": 1073, + "statement_ns": 2654900, + "success": true + }, + { + "mutex_wait_ns": 2663200, + "serialization_ns": 6500, + "serialized_bytes": 1073, + "statement_ns": 2532700, + "success": true + }, + { + "mutex_wait_ns": 2545600, + "serialization_ns": 6000, + "serialized_bytes": 1081, + "statement_ns": 2935900, + "success": true + }, + { + "mutex_wait_ns": 2953400, + "serialization_ns": 6100, + "serialized_bytes": 1081, + "statement_ns": 2694700, + "success": true + }, + { + "mutex_wait_ns": 2699000, + "serialization_ns": 6000, + "serialized_bytes": 1297, + "statement_ns": 3335000, + "success": true + }, + { + "mutex_wait_ns": 3362000, + "serialization_ns": 6800, + "serialized_bytes": 1297, + "statement_ns": 4405300, + "success": true + }, + { + "mutex_wait_ns": 4082800, + "serialization_ns": 3400, + "serialized_bytes": 610, + "statement_ns": 3346500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4300, + "serialized_bytes": 610, + "statement_ns": 2226300, + "success": true + }, + { + "mutex_wait_ns": 5511100, + "serialization_ns": 3700, + "serialized_bytes": 612, + "statement_ns": 2859800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5300, + "serialized_bytes": 612, + "statement_ns": 2413300, + "success": true + }, + { + "mutex_wait_ns": 5304500, + "serialization_ns": 5100, + "serialized_bytes": 1034, + "statement_ns": 2685600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6400, + "serialized_bytes": 1073, + "statement_ns": 2501000, + "success": true + }, + { + "mutex_wait_ns": 5227800, + "serialization_ns": 5400, + "serialized_bytes": 1038, + "statement_ns": 2926800, + "success": true + }, + { + "mutex_wait_ns": 2941600, + "serialization_ns": 8000, + "serialized_bytes": 1081, + "statement_ns": 3539200, + "success": true + }, + { + "mutex_wait_ns": 3551200, + "serialization_ns": 6100, + "serialized_bytes": 1077, + "statement_ns": 3251300, + "success": true + }, + { + "mutex_wait_ns": 3261600, + "serialization_ns": 7100, + "serialized_bytes": 1297, + "statement_ns": 5105600, + "success": true + }, + { + "mutex_wait_ns": 5124300, + "serialization_ns": 8900, + "serialized_bytes": 1085, + "statement_ns": 2778000, + "success": true + }, + { + "mutex_wait_ns": 2689500, + "serialization_ns": 3900, + "serialized_bytes": 612, + "statement_ns": 3593400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4700, + "serialized_bytes": 612, + "statement_ns": 2338300, + "success": true + }, + { + "mutex_wait_ns": 5956100, + "serialization_ns": 11000, + "serialized_bytes": 1301, + "statement_ns": 2780400, + "success": true + }, + { + "mutex_wait_ns": 2792700, + "serialization_ns": 5100, + "serialized_bytes": 1038, + "statement_ns": 4179100, + "success": true + }, + { + "mutex_wait_ns": 4098400, + "serialization_ns": 3300, + "serialized_bytes": 612, + "statement_ns": 3001600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5300, + "serialized_bytes": 612, + "statement_ns": 3381600, + "success": true + }, + { + "mutex_wait_ns": 6417100, + "serialization_ns": 8300, + "serialized_bytes": 1077, + "statement_ns": 4027300, + "success": true + }, + { + "mutex_wait_ns": 4038400, + "serialization_ns": 5800, + "serialized_bytes": 1038, + "statement_ns": 3159500, + "success": true + }, + { + "mutex_wait_ns": 3177800, + "serialization_ns": 7700, + "serialized_bytes": 1085, + "statement_ns": 2641500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7000, + "serialized_bytes": 1301, + "statement_ns": 2647600, + "success": true + }, + { + "mutex_wait_ns": 5337900, + "serialization_ns": 6600, + "serialized_bytes": 1077, + "statement_ns": 2759600, + "success": true + }, + { + "mutex_wait_ns": 2683100, + "serialization_ns": 3400, + "serialized_bytes": 610, + "statement_ns": 2822900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4200, + "serialized_bytes": 610, + "statement_ns": 2540700, + "success": true + }, + { + "mutex_wait_ns": 5397300, + "serialization_ns": 8300, + "serialized_bytes": 1085, + "statement_ns": 3136800, + "success": true + }, + { + "mutex_wait_ns": 3154000, + "serialization_ns": 5300, + "serialized_bytes": 1034, + "statement_ns": 2807500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5300, + "serialized_bytes": 1073, + "statement_ns": 2777200, + "success": true + }, + { + "mutex_wait_ns": 5624700, + "serialization_ns": 6200, + "serialized_bytes": 1301, + "statement_ns": 2935500, + "success": true + }, + { + "mutex_wait_ns": 2950500, + "serialization_ns": 7900, + "serialized_bytes": 1081, + "statement_ns": 2661000, + "success": true + }, + { + "mutex_wait_ns": 2555200, + "serialization_ns": 4000, + "serialized_bytes": 612, + "statement_ns": 3256200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 9000, + "serialized_bytes": 612, + "statement_ns": 2795000, + "success": true + }, + { + "mutex_wait_ns": 6088100, + "serialization_ns": 7000, + "serialized_bytes": 1297, + "statement_ns": 2937800, + "success": true + }, + { + "mutex_wait_ns": 2952000, + "serialization_ns": 6400, + "serialized_bytes": 1038, + "statement_ns": 3153500, + "success": true + }, + { + "mutex_wait_ns": 3067300, + "serialization_ns": 3300, + "serialized_bytes": 612, + "statement_ns": 2907800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4400, + "serialized_bytes": 612, + "statement_ns": 2711500, + "success": true + }, + { + "mutex_wait_ns": 5646000, + "serialization_ns": 7300, + "serialized_bytes": 1077, + "statement_ns": 2654600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7500, + "serialized_bytes": 1085, + "statement_ns": 3128400, + "success": true + }, + { + "mutex_wait_ns": 5826800, + "serialization_ns": 5900, + "serialized_bytes": 1038, + "statement_ns": 4089600, + "success": true + }, + { + "mutex_wait_ns": 4101800, + "serialization_ns": 7300, + "serialized_bytes": 1301, + "statement_ns": 2232900, + "success": true + }, + { + "mutex_wait_ns": 2241800, + "serialization_ns": 7500, + "serialized_bytes": 1077, + "statement_ns": 2323900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7100, + "serialized_bytes": 1085, + "statement_ns": 2828400, + "success": true + }, + { + "mutex_wait_ns": 5080500, + "serialization_ns": 3400, + "serialized_bytes": 610, + "statement_ns": 2915700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5300, + "serialized_bytes": 610, + "statement_ns": 2558700, + "success": true + }, + { + "mutex_wait_ns": 5513100, + "serialization_ns": 6500, + "serialized_bytes": 1301, + "statement_ns": 2855800, + "success": true + }, + { + "mutex_wait_ns": 2867600, + "serialization_ns": 6200, + "serialized_bytes": 1034, + "statement_ns": 2567100, + "success": true + }, + { + "mutex_wait_ns": 2476600, + "serialization_ns": 3600, + "serialized_bytes": 610, + "statement_ns": 2988600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4800, + "serialized_bytes": 610, + "statement_ns": 2878500, + "success": true + }, + { + "mutex_wait_ns": 5891400, + "serialization_ns": 8200, + "serialized_bytes": 1073, + "statement_ns": 2625700, + "success": true + }, + { + "mutex_wait_ns": 2641200, + "serialization_ns": 5500, + "serialized_bytes": 1034, + "statement_ns": 2932400, + "success": true + }, + { + "mutex_wait_ns": 2953600, + "serialization_ns": 5900, + "serialized_bytes": 1081, + "statement_ns": 2543500, + "success": true + }, + { + "mutex_wait_ns": 2557400, + "serialization_ns": 6000, + "serialized_bytes": 1073, + "statement_ns": 2263700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7200, + "serialized_bytes": 1081, + "statement_ns": 3168400, + "success": true + }, + { + "mutex_wait_ns": 5467500, + "serialization_ns": 8800, + "serialized_bytes": 1297, + "statement_ns": 2596500, + "success": true + }, + { + "mutex_wait_ns": 2610200, + "serialization_ns": 7800, + "serialized_bytes": 1297, + "statement_ns": 3273100, + "success": true + }, + { + "mutex_wait_ns": 3181300, + "serialization_ns": 3900, + "serialized_bytes": 610, + "statement_ns": 3140300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 610, + "statement_ns": 2719600, + "success": true + }, + { + "mutex_wait_ns": 5828600, + "serialization_ns": 3600, + "serialized_bytes": 612, + "statement_ns": 2760600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6400, + "serialized_bytes": 612, + "statement_ns": 3238400, + "success": true + }, + { + "mutex_wait_ns": 6045700, + "serialization_ns": 6000, + "serialized_bytes": 1034, + "statement_ns": 3208000, + "success": true + }, + { + "mutex_wait_ns": 3233600, + "serialization_ns": 6600, + "serialized_bytes": 1038, + "statement_ns": 2889100, + "success": true + }, + { + "mutex_wait_ns": 2902000, + "serialization_ns": 7400, + "serialized_bytes": 1073, + "statement_ns": 2653300, + "success": true + }, + { + "mutex_wait_ns": 2668300, + "serialization_ns": 7400, + "serialized_bytes": 1077, + "statement_ns": 3061200, + "success": true + }, + { + "mutex_wait_ns": 3082200, + "serialization_ns": 8100, + "serialized_bytes": 1081, + "statement_ns": 2407200, + "success": true + }, + { + "mutex_wait_ns": 2434300, + "serialization_ns": 7000, + "serialized_bytes": 1085, + "statement_ns": 2479500, + "success": true + }, + { + "mutex_wait_ns": 2498500, + "serialization_ns": 6400, + "serialized_bytes": 1297, + "statement_ns": 3597100, + "success": true + }, + { + "mutex_wait_ns": 3613900, + "serialization_ns": 7200, + "serialized_bytes": 1301, + "statement_ns": 3042500, + "success": true + }, + { + "mutex_wait_ns": 2940600, + "serialization_ns": 4600, + "serialized_bytes": 612, + "statement_ns": 3035100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4900, + "serialized_bytes": 612, + "statement_ns": 3469100, + "success": true + }, + { + "mutex_wait_ns": 6409400, + "serialization_ns": 3100, + "serialized_bytes": 612, + "statement_ns": 2845000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4800, + "serialized_bytes": 612, + "statement_ns": 2477400, + "success": true + }, + { + "mutex_wait_ns": 5362600, + "serialization_ns": 5800, + "serialized_bytes": 1038, + "statement_ns": 4182600, + "success": true + }, + { + "mutex_wait_ns": 4202300, + "serialization_ns": 6400, + "serialized_bytes": 1038, + "statement_ns": 2393700, + "success": true + }, + { + "mutex_wait_ns": 2409200, + "serialization_ns": 6400, + "serialized_bytes": 1077, + "statement_ns": 2421300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6600, + "serialized_bytes": 1085, + "statement_ns": 4043300, + "success": true + }, + { + "mutex_wait_ns": 6502600, + "serialization_ns": 5900, + "serialized_bytes": 1077, + "statement_ns": 2493100, + "success": true + }, + { + "mutex_wait_ns": 2507900, + "serialization_ns": 6800, + "serialized_bytes": 1301, + "statement_ns": 2631500, + "success": true + }, + { + "mutex_wait_ns": 2653500, + "serialization_ns": 7200, + "serialized_bytes": 1085, + "statement_ns": 3282200, + "success": true + }, + { + "mutex_wait_ns": 3200000, + "serialization_ns": 3200, + "serialized_bytes": 612, + "statement_ns": 5381000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5100, + "serialized_bytes": 612, + "statement_ns": 2465300, + "success": true + }, + { + "mutex_wait_ns": 7877300, + "serialization_ns": 6900, + "serialized_bytes": 1301, + "statement_ns": 4465000, + "success": true + }, + { + "mutex_wait_ns": 4486800, + "serialization_ns": 5200, + "serialized_bytes": 1038, + "statement_ns": 3216500, + "success": true + }, + { + "mutex_wait_ns": 3112900, + "serialization_ns": 4300, + "serialized_bytes": 612, + "statement_ns": 2772400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4000, + "serialized_bytes": 612, + "statement_ns": 2549400, + "success": true + }, + { + "mutex_wait_ns": 5350000, + "serialization_ns": 6200, + "serialized_bytes": 1077, + "statement_ns": 2401000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1085, + "statement_ns": 2693000, + "success": true + }, + { + "mutex_wait_ns": 5132300, + "serialization_ns": 5400, + "serialized_bytes": 1038, + "statement_ns": 3249900, + "success": true + }, + { + "mutex_wait_ns": 3264800, + "serialization_ns": 7200, + "serialized_bytes": 1301, + "statement_ns": 3226600, + "success": true + }, + { + "mutex_wait_ns": 3242600, + "serialization_ns": 6900, + "serialized_bytes": 1077, + "statement_ns": 4219100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7600, + "serialized_bytes": 1085, + "statement_ns": 4067200, + "success": true + }, + { + "mutex_wait_ns": 8224200, + "serialization_ns": 4000, + "serialized_bytes": 612, + "statement_ns": 4551600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7100, + "serialized_bytes": 612, + "statement_ns": 2794600, + "success": true + }, + { + "mutex_wait_ns": 7398000, + "serialization_ns": 6300, + "serialized_bytes": 1301, + "statement_ns": 2983300, + "success": true + }, + { + "mutex_wait_ns": 3016600, + "serialization_ns": 6000, + "serialized_bytes": 1038, + "statement_ns": 2930000, + "success": true + }, + { + "mutex_wait_ns": 2816900, + "serialization_ns": 3600, + "serialized_bytes": 612, + "statement_ns": 2648600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4400, + "serialized_bytes": 612, + "statement_ns": 2867300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5100, + "serialized_bytes": 1038, + "statement_ns": 3107300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5300, + "serialized_bytes": 1077, + "statement_ns": 2566500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1085, + "statement_ns": 2768300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1301, + "statement_ns": 2458300, + "success": true + }, + { + "mutex_wait_ns": 16538200, + "serialization_ns": 7900, + "serialized_bytes": 1077, + "statement_ns": 2740700, + "success": true + }, + { + "mutex_wait_ns": 2633900, + "serialization_ns": 3000, + "serialized_bytes": 612, + "statement_ns": 3091700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3900, + "serialized_bytes": 612, + "statement_ns": 2797900, + "success": true + }, + { + "mutex_wait_ns": 5922500, + "serialization_ns": 9300, + "serialized_bytes": 1085, + "statement_ns": 2427300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6000, + "serialized_bytes": 1301, + "statement_ns": 2995900, + "success": true + }, + { + "mutex_wait_ns": 5477800, + "serialization_ns": 5400, + "serialized_bytes": 1038, + "statement_ns": 2820500, + "success": true + }, + { + "mutex_wait_ns": 2729500, + "serialization_ns": 3800, + "serialized_bytes": 612, + "statement_ns": 2605800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5100, + "serialized_bytes": 612, + "statement_ns": 2724400, + "success": true + }, + { + "mutex_wait_ns": 5350300, + "serialization_ns": 7300, + "serialized_bytes": 1077, + "statement_ns": 2934900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7500, + "serialized_bytes": 1085, + "statement_ns": 3076000, + "success": true + }, + { + "mutex_wait_ns": 6038100, + "serialization_ns": 7900, + "serialized_bytes": 1038, + "statement_ns": 2600100, + "success": true + }, + { + "mutex_wait_ns": 2606500, + "serialization_ns": 7200, + "serialized_bytes": 1301, + "statement_ns": 2543000, + "success": true + }, + { + "mutex_wait_ns": 2565300, + "serialization_ns": 5300, + "serialized_bytes": 1077, + "statement_ns": 2447300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1085, + "statement_ns": 2625900, + "success": true + }, + { + "mutex_wait_ns": 5013600, + "serialization_ns": 3200, + "serialized_bytes": 612, + "statement_ns": 2757700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3900, + "serialized_bytes": 612, + "statement_ns": 2695600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4900, + "serialized_bytes": 1038, + "statement_ns": 2520800, + "success": true + }, + { + "mutex_wait_ns": 8034700, + "serialization_ns": 6700, + "serialized_bytes": 1301, + "statement_ns": 3355200, + "success": true + }, + { + "mutex_wait_ns": 3372000, + "serialization_ns": 5700, + "serialized_bytes": 1077, + "statement_ns": 3200100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1085, + "statement_ns": 2466600, + "success": true + }, + { + "mutex_wait_ns": 5585100, + "serialization_ns": 3900, + "serialized_bytes": 612, + "statement_ns": 2598800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4000, + "serialized_bytes": 612, + "statement_ns": 2842400, + "success": true + }, + { + "mutex_wait_ns": 5473400, + "serialization_ns": 6000, + "serialized_bytes": 1301, + "statement_ns": 2843500, + "success": true + }, + { + "mutex_wait_ns": 2855200, + "serialization_ns": 5200, + "serialized_bytes": 1038, + "statement_ns": 2941700, + "success": true + }, + { + "mutex_wait_ns": 2851900, + "serialization_ns": 3200, + "serialized_bytes": 610, + "statement_ns": 3937700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3200, + "serialized_bytes": 610, + "statement_ns": 2571000, + "success": true + }, + { + "mutex_wait_ns": 6538600, + "serialization_ns": 6500, + "serialized_bytes": 1077, + "statement_ns": 2918000, + "success": true + }, + { + "mutex_wait_ns": 500, + "serialization_ns": 5500, + "serialized_bytes": 1085, + "statement_ns": 2790900, + "success": true + }, + { + "mutex_wait_ns": 5753300, + "serialization_ns": 5800, + "serialized_bytes": 1034, + "statement_ns": 2409900, + "success": true + }, + { + "mutex_wait_ns": 2425100, + "serialization_ns": 8500, + "serialized_bytes": 1301, + "statement_ns": 3062700, + "success": true + }, + { + "mutex_wait_ns": 3080600, + "serialization_ns": 5700, + "serialized_bytes": 1073, + "statement_ns": 2951000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 6200, + "serialized_bytes": 1081, + "statement_ns": 2533500, + "success": true + }, + { + "mutex_wait_ns": 5406400, + "serialization_ns": 4600, + "serialized_bytes": 612, + "statement_ns": 3162600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5300, + "serialized_bytes": 612, + "statement_ns": 2887100, + "success": true + }, + { + "mutex_wait_ns": 6084900, + "serialization_ns": 6300, + "serialized_bytes": 1297, + "statement_ns": 2567600, + "success": true + }, + { + "mutex_wait_ns": 2580000, + "serialization_ns": 7300, + "serialized_bytes": 1038, + "statement_ns": 2690700, + "success": true + }, + { + "mutex_wait_ns": 2600200, + "serialization_ns": 4000, + "serialized_bytes": 612, + "statement_ns": 3379300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3900, + "serialized_bytes": 612, + "statement_ns": 3011000, + "success": true + }, + { + "mutex_wait_ns": 6417300, + "serialization_ns": 6600, + "serialized_bytes": 1077, + "statement_ns": 2553500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5900, + "serialized_bytes": 1085, + "statement_ns": 2473300, + "success": true + }, + { + "mutex_wait_ns": 5071600, + "serialization_ns": 4900, + "serialized_bytes": 1038, + "statement_ns": 2538400, + "success": true + }, + { + "mutex_wait_ns": 2561300, + "serialization_ns": 7600, + "serialized_bytes": 1301, + "statement_ns": 2854300, + "success": true + }, + { + "mutex_wait_ns": 2870700, + "serialization_ns": 6400, + "serialized_bytes": 1077, + "statement_ns": 2499200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1085, + "statement_ns": 2714900, + "success": true + }, + { + "mutex_wait_ns": 5132300, + "serialization_ns": 4100, + "serialized_bytes": 610, + "statement_ns": 3215800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5400, + "serialized_bytes": 610, + "statement_ns": 2876800, + "success": true + }, + { + "mutex_wait_ns": 6135200, + "serialization_ns": 5800, + "serialized_bytes": 1301, + "statement_ns": 2974700, + "success": true + }, + { + "mutex_wait_ns": 2987900, + "serialization_ns": 6800, + "serialized_bytes": 1034, + "statement_ns": 3215400, + "success": true + }, + { + "mutex_wait_ns": 3116300, + "serialization_ns": 3500, + "serialized_bytes": 612, + "statement_ns": 2903900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4500, + "serialized_bytes": 612, + "statement_ns": 2416900, + "success": true + }, + { + "mutex_wait_ns": 5347300, + "serialization_ns": 5900, + "serialized_bytes": 1073, + "statement_ns": 4037900, + "success": true + }, + { + "mutex_wait_ns": 4055400, + "serialization_ns": 5600, + "serialized_bytes": 1038, + "statement_ns": 2522300, + "success": true + }, + { + "mutex_wait_ns": 2539800, + "serialization_ns": 5800, + "serialized_bytes": 1081, + "statement_ns": 2603100, + "success": true + }, + { + "mutex_wait_ns": 2610300, + "serialization_ns": 7500, + "serialized_bytes": 1077, + "statement_ns": 2562300, + "success": true + }, + { + "mutex_wait_ns": 2571500, + "serialization_ns": 8700, + "serialized_bytes": 1297, + "statement_ns": 2710600, + "success": true + }, + { + "mutex_wait_ns": 2730200, + "serialization_ns": 9600, + "serialized_bytes": 1085, + "statement_ns": 2474600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6500, + "serialized_bytes": 1301, + "statement_ns": 2410600, + "success": true + }, + { + "mutex_wait_ns": 4802400, + "serialization_ns": 3900, + "serialized_bytes": 612, + "statement_ns": 2639300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4500, + "serialized_bytes": 612, + "statement_ns": 2383500, + "success": true + }, + { + "mutex_wait_ns": 4962800, + "serialization_ns": 3200, + "serialized_bytes": 612, + "statement_ns": 3106500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4300, + "serialized_bytes": 612, + "statement_ns": 3448100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1038, + "statement_ns": 2679100, + "success": true + }, + { + "mutex_wait_ns": 9288900, + "serialization_ns": 6100, + "serialized_bytes": 1038, + "statement_ns": 2423100, + "success": true + }, + { + "mutex_wait_ns": 2440400, + "serialization_ns": 5200, + "serialized_bytes": 1077, + "statement_ns": 2931900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7300, + "serialized_bytes": 1085, + "statement_ns": 3107800, + "success": true + }, + { + "mutex_wait_ns": 6068500, + "serialization_ns": 8800, + "serialized_bytes": 1077, + "statement_ns": 2609800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5600, + "serialized_bytes": 1085, + "statement_ns": 2967100, + "success": true + }, + { + "mutex_wait_ns": 5606400, + "serialization_ns": 6500, + "serialized_bytes": 1301, + "statement_ns": 2585600, + "success": true + }, + { + "mutex_wait_ns": 2602800, + "serialization_ns": 6700, + "serialized_bytes": 1301, + "statement_ns": 3044000, + "success": true + }, + { + "mutex_wait_ns": 2958400, + "serialization_ns": 3700, + "serialized_bytes": 612, + "statement_ns": 3020100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3900, + "serialized_bytes": 612, + "statement_ns": 2342200, + "success": true + }, + { + "mutex_wait_ns": 5304800, + "serialization_ns": 3200, + "serialized_bytes": 610, + "statement_ns": 2878200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3900, + "serialized_bytes": 610, + "statement_ns": 2507300, + "success": true + }, + { + "mutex_wait_ns": 5413700, + "serialization_ns": 5600, + "serialized_bytes": 1038, + "statement_ns": 3698500, + "success": true + }, + { + "mutex_wait_ns": 3709400, + "serialization_ns": 5500, + "serialized_bytes": 1034, + "statement_ns": 2434200, + "success": true + }, + { + "mutex_wait_ns": 2440600, + "serialization_ns": 6800, + "serialized_bytes": 1077, + "statement_ns": 2753300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 1085, + "statement_ns": 2669500, + "success": true + }, + { + "mutex_wait_ns": 5454700, + "serialization_ns": 5100, + "serialized_bytes": 1073, + "statement_ns": 2604700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1081, + "statement_ns": 2340500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6600, + "serialized_bytes": 1297, + "statement_ns": 2435500, + "success": true + }, + { + "mutex_wait_ns": 7438100, + "serialization_ns": 6100, + "serialized_bytes": 1301, + "statement_ns": 4505100, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 2415500, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=0", + "COMPILER=msvc-1944", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_W32", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "HTTP", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 563188200, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 269816700, + 269845500, + 269653600, + 269613100, + 269518100, + 269474000, + 269337300, + 269286100, + 269225300, + 269193300, + 269102300, + 269122000, + 268972900, + 268982900, + 268880300, + 492035700, + 547553100, + 547066700, + 546784200, + 546727300, + 546677900, + 546452600, + 546337400, + 546343700, + 546250100, + 546249300, + 546151600, + 546136700, + 546045300, + 546844300, + 546836500, + 561107700 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 352800, + 259714300, + 267950500, + 389800, + 308600, + 396300 + ], + "failures": 0, + "in_window_samples": 4, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 352800, + "end_ns": 11353400, + "in_window": true, + "scheduled_ns": null, + "start_ns": 11000600, + "success": true + }, + { + "elapsed_ns": 259714300, + "end_ns": 281228100, + "in_window": true, + "scheduled_ns": null, + "start_ns": 21513800, + "success": true + }, + { + "elapsed_ns": 267950500, + "end_ns": 559688600, + "in_window": true, + "scheduled_ns": null, + "start_ns": 291738100, + "success": true + }, + { + "elapsed_ns": 389800, + "end_ns": 570276200, + "in_window": true, + "scheduled_ns": null, + "start_ns": 569886400, + "success": true + }, + { + "elapsed_ns": 308600, + "end_ns": 580665400, + "in_window": false, + "scheduled_ns": null, + "start_ns": 580356800, + "success": true + }, + { + "elapsed_ns": 396300, + "end_ns": 591165700, + "in_window": false, + "scheduled_ns": null, + "start_ns": 590769400, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 259682300, + 9795900, + 243696900, + 18741900, + 5129700, + 3053000, + 9723800, + 7064600, + 13117600 + ], + "failures": 0, + "in_window_samples": 6, + "missed_periods": 51, + "samples": [ + { + "elapsed_ns": 259682300, + "end_ns": 280948000, + "in_window": true, + "scheduled_ns": 21265700, + "start_ns": 280948000, + "success": true + }, + { + "elapsed_ns": 9795900, + "end_ns": 291061600, + "in_window": true, + "scheduled_ns": 281265700, + "start_ns": 291061600, + "success": true + }, + { + "elapsed_ns": 243696900, + "end_ns": 534962600, + "in_window": true, + "scheduled_ns": 291265700, + "start_ns": 534962600, + "success": true + }, + { + "elapsed_ns": 18741900, + "end_ns": 560007600, + "in_window": true, + "scheduled_ns": 541265700, + "start_ns": 560007600, + "success": true + }, + { + "elapsed_ns": 5129700, + "end_ns": 566395400, + "in_window": true, + "scheduled_ns": 561265700, + "start_ns": 566395400, + "success": true + }, + { + "elapsed_ns": 3053000, + "end_ns": 574318700, + "in_window": true, + "scheduled_ns": 571265700, + "start_ns": 574318700, + "success": true + }, + { + "elapsed_ns": 9723800, + "end_ns": 590989500, + "in_window": false, + "scheduled_ns": 581265700, + "start_ns": 590989500, + "success": true + }, + { + "elapsed_ns": 7064600, + "end_ns": 598330300, + "in_window": false, + "scheduled_ns": 591265700, + "start_ns": 598330300, + "success": true + }, + { + "elapsed_ns": 13117600, + "end_ns": 614383300, + "in_window": false, + "scheduled_ns": 601265700, + "start_ns": 614383300, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 574481800, + "window_start_ns": 11293600 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 1, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 100, + "serialization_ns": 7200, + "serialized_bytes": 612, + "statement_ns": 2861100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3900, + "serialized_bytes": 612, + "statement_ns": 2678900, + "success": true + }, + { + "mutex_wait_ns": 5104200, + "serialization_ns": 4200, + "serialized_bytes": 612, + "statement_ns": 3702400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5100, + "serialized_bytes": 612, + "statement_ns": 2804800, + "success": true + }, + { + "mutex_wait_ns": 6538500, + "serialization_ns": 6300, + "serialized_bytes": 1038, + "statement_ns": 2643400, + "success": true + }, + { + "mutex_wait_ns": 2655400, + "serialization_ns": 5700, + "serialized_bytes": 1038, + "statement_ns": 3989400, + "success": true + }, + { + "mutex_wait_ns": 3995300, + "serialization_ns": 6200, + "serialized_bytes": 1077, + "statement_ns": 2304800, + "success": true + }, + { + "mutex_wait_ns": 2308200, + "serialization_ns": 7300, + "serialized_bytes": 1077, + "statement_ns": 2532500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5200, + "serialized_bytes": 1085, + "statement_ns": 2753200, + "success": true + }, + { + "mutex_wait_ns": 5322600, + "serialization_ns": 6600, + "serialized_bytes": 1085, + "statement_ns": 2319500, + "success": true + }, + { + "mutex_wait_ns": 2334300, + "serialization_ns": 6900, + "serialized_bytes": 1301, + "statement_ns": 2555100, + "success": true + }, + { + "mutex_wait_ns": 2565300, + "serialization_ns": 6700, + "serialized_bytes": 1301, + "statement_ns": 2997400, + "success": true + }, + { + "mutex_wait_ns": 2910400, + "serialization_ns": 3300, + "serialized_bytes": 612, + "statement_ns": 2950200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4000, + "serialized_bytes": 612, + "statement_ns": 2845200, + "success": true + }, + { + "mutex_wait_ns": 5683600, + "serialization_ns": 2800, + "serialized_bytes": 612, + "statement_ns": 2951500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4000, + "serialized_bytes": 612, + "statement_ns": 2917100, + "success": true + }, + { + "mutex_wait_ns": 5897600, + "serialization_ns": 4800, + "serialized_bytes": 1038, + "statement_ns": 2632400, + "success": true + }, + { + "mutex_wait_ns": 2646400, + "serialization_ns": 5100, + "serialized_bytes": 1038, + "statement_ns": 2431300, + "success": true + }, + { + "mutex_wait_ns": 2435500, + "serialization_ns": 5300, + "serialized_bytes": 1077, + "statement_ns": 3152500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4500, + "serialized_bytes": 1085, + "statement_ns": 2891200, + "success": true + }, + { + "mutex_wait_ns": 6081400, + "serialization_ns": 5200, + "serialized_bytes": 1077, + "statement_ns": 3401800, + "success": true + }, + { + "mutex_wait_ns": 3420300, + "serialization_ns": 7000, + "serialized_bytes": 1301, + "statement_ns": 3036400, + "success": true + }, + { + "mutex_wait_ns": 3052000, + "serialization_ns": 6800, + "serialized_bytes": 1085, + "statement_ns": 2669500, + "success": true + }, + { + "mutex_wait_ns": 2584900, + "serialization_ns": 3200, + "serialized_bytes": 612, + "statement_ns": 2815500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4000, + "serialized_bytes": 612, + "statement_ns": 3006300, + "success": true + }, + { + "mutex_wait_ns": 5854400, + "serialization_ns": 6400, + "serialized_bytes": 1301, + "statement_ns": 3106000, + "success": true + }, + { + "mutex_wait_ns": 3135900, + "serialization_ns": 5900, + "serialized_bytes": 1038, + "statement_ns": 3327700, + "success": true + }, + { + "mutex_wait_ns": 3210300, + "serialization_ns": 4500, + "serialized_bytes": 612, + "statement_ns": 2745600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4600, + "serialized_bytes": 612, + "statement_ns": 2640100, + "success": true + }, + { + "mutex_wait_ns": 5408800, + "serialization_ns": 6900, + "serialized_bytes": 1077, + "statement_ns": 2481800, + "success": true + }, + { + "mutex_wait_ns": 2492300, + "serialization_ns": 5800, + "serialized_bytes": 1038, + "statement_ns": 2447000, + "success": true + }, + { + "mutex_wait_ns": 2464800, + "serialization_ns": 5900, + "serialized_bytes": 1085, + "statement_ns": 2305900, + "success": true + }, + { + "mutex_wait_ns": 2313200, + "serialization_ns": 5700, + "serialized_bytes": 1077, + "statement_ns": 2983300, + "success": true + }, + { + "mutex_wait_ns": 2998300, + "serialization_ns": 5400, + "serialized_bytes": 1301, + "statement_ns": 2493000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3400, + "serialized_bytes": 610, + "statement_ns": 2697900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3900, + "serialized_bytes": 610, + "statement_ns": 2641300, + "success": true + }, + { + "mutex_wait_ns": 7985100, + "serialization_ns": 5100, + "serialized_bytes": 1085, + "statement_ns": 2419200, + "success": true + }, + { + "mutex_wait_ns": 2437600, + "serialization_ns": 5200, + "serialized_bytes": 1034, + "statement_ns": 2743800, + "success": true + }, + { + "mutex_wait_ns": 2755800, + "serialization_ns": 6800, + "serialized_bytes": 1301, + "statement_ns": 2361100, + "success": true + }, + { + "mutex_wait_ns": 2371800, + "serialization_ns": 5800, + "serialized_bytes": 1073, + "statement_ns": 2179400, + "success": true + }, + { + "mutex_wait_ns": 2088200, + "serialization_ns": 3500, + "serialized_bytes": 612, + "statement_ns": 4755200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4100, + "serialized_bytes": 612, + "statement_ns": 2945700, + "success": true + }, + { + "mutex_wait_ns": 7738100, + "serialization_ns": 6300, + "serialized_bytes": 1081, + "statement_ns": 2554000, + "success": true + }, + { + "mutex_wait_ns": 2566500, + "serialization_ns": 7000, + "serialized_bytes": 1038, + "statement_ns": 2954700, + "success": true + }, + { + "mutex_wait_ns": 2965800, + "serialization_ns": 6700, + "serialized_bytes": 1297, + "statement_ns": 3061000, + "success": true + }, + { + "mutex_wait_ns": 3076500, + "serialization_ns": 5400, + "serialized_bytes": 1077, + "statement_ns": 2756500, + "success": true + }, + { + "mutex_wait_ns": 2605900, + "serialization_ns": 3400, + "serialized_bytes": 612, + "statement_ns": 2793700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4900, + "serialized_bytes": 612, + "statement_ns": 2543100, + "success": true + }, + { + "mutex_wait_ns": 5372300, + "serialization_ns": 6900, + "serialized_bytes": 1085, + "statement_ns": 2968300, + "success": true + }, + { + "mutex_wait_ns": 2981400, + "serialization_ns": 5700, + "serialized_bytes": 1038, + "statement_ns": 2675500, + "success": true + }, + { + "mutex_wait_ns": 2688600, + "serialization_ns": 6400, + "serialized_bytes": 1301, + "statement_ns": 2339200, + "success": true + }, + { + "mutex_wait_ns": 2348000, + "serialization_ns": 6200, + "serialized_bytes": 1077, + "statement_ns": 3215900, + "success": true + }, + { + "mutex_wait_ns": 3124400, + "serialization_ns": 3200, + "serialized_bytes": 610, + "statement_ns": 2811300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4400, + "serialized_bytes": 610, + "statement_ns": 2268000, + "success": true + }, + { + "mutex_wait_ns": 5118200, + "serialization_ns": 6200, + "serialized_bytes": 1085, + "statement_ns": 2287400, + "success": true + }, + { + "mutex_wait_ns": 2301100, + "serialization_ns": 6400, + "serialized_bytes": 1034, + "statement_ns": 2811500, + "success": true + }, + { + "mutex_wait_ns": 2824100, + "serialization_ns": 6300, + "serialized_bytes": 1301, + "statement_ns": 3603400, + "success": true + }, + { + "mutex_wait_ns": 3618600, + "serialization_ns": 5300, + "serialized_bytes": 1073, + "statement_ns": 4172700, + "success": true + }, + { + "mutex_wait_ns": 4085400, + "serialization_ns": 3400, + "serialized_bytes": 610, + "statement_ns": 3046400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4500, + "serialized_bytes": 610, + "statement_ns": 2551000, + "success": true + }, + { + "mutex_wait_ns": 5632600, + "serialization_ns": 6700, + "serialized_bytes": 1081, + "statement_ns": 2989000, + "success": true + }, + { + "mutex_wait_ns": 3014100, + "serialization_ns": 5400, + "serialized_bytes": 1034, + "statement_ns": 3204000, + "success": true + }, + { + "mutex_wait_ns": 3223200, + "serialization_ns": 7200, + "serialized_bytes": 1297, + "statement_ns": 2934100, + "success": true + }, + { + "mutex_wait_ns": 2944000, + "serialization_ns": 6400, + "serialized_bytes": 1073, + "statement_ns": 2696300, + "success": true + }, + { + "mutex_wait_ns": 2667300, + "serialization_ns": 3500, + "serialized_bytes": 610, + "statement_ns": 2726100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4300, + "serialized_bytes": 610, + "statement_ns": 2331000, + "success": true + }, + { + "mutex_wait_ns": 5091700, + "serialization_ns": 6800, + "serialized_bytes": 1081, + "statement_ns": 2622000, + "success": true + }, + { + "mutex_wait_ns": 2635400, + "serialization_ns": 5400, + "serialized_bytes": 1034, + "statement_ns": 2131600, + "success": true + }, + { + "mutex_wait_ns": 2148600, + "serialization_ns": 5600, + "serialized_bytes": 1297, + "statement_ns": 2769500, + "success": true + }, + { + "mutex_wait_ns": 2791600, + "serialization_ns": 5100, + "serialized_bytes": 1073, + "statement_ns": 2940900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6400, + "serialized_bytes": 1081, + "statement_ns": 2566600, + "success": true + }, + { + "mutex_wait_ns": 5411300, + "serialization_ns": 3100, + "serialized_bytes": 612, + "statement_ns": 2638400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4300, + "serialized_bytes": 612, + "statement_ns": 2437900, + "success": true + }, + { + "mutex_wait_ns": 5107200, + "serialization_ns": 6500, + "serialized_bytes": 1297, + "statement_ns": 2709200, + "success": true + }, + { + "mutex_wait_ns": 2725500, + "serialization_ns": 4600, + "serialized_bytes": 1038, + "statement_ns": 3070900, + "success": true + }, + { + "mutex_wait_ns": 2970200, + "serialization_ns": 3400, + "serialized_bytes": 612, + "statement_ns": 2876900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3300, + "serialized_bytes": 612, + "statement_ns": 3871900, + "success": true + }, + { + "mutex_wait_ns": 6772100, + "serialization_ns": 6700, + "serialized_bytes": 1077, + "statement_ns": 2906100, + "success": true + }, + { + "mutex_wait_ns": 2918300, + "serialization_ns": 5600, + "serialized_bytes": 1038, + "statement_ns": 3156500, + "success": true + }, + { + "mutex_wait_ns": 3174100, + "serialization_ns": 6300, + "serialized_bytes": 1085, + "statement_ns": 2523400, + "success": true + }, + { + "mutex_wait_ns": 2530100, + "serialization_ns": 6800, + "serialized_bytes": 1077, + "statement_ns": 3043900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1085, + "statement_ns": 2388200, + "success": true + }, + { + "mutex_wait_ns": 5465500, + "serialization_ns": 6700, + "serialized_bytes": 1301, + "statement_ns": 2790000, + "success": true + }, + { + "mutex_wait_ns": 2799600, + "serialization_ns": 8300, + "serialized_bytes": 1301, + "statement_ns": 2416500, + "success": true + }, + { + "mutex_wait_ns": 2303800, + "serialization_ns": 3200, + "serialized_bytes": 612, + "statement_ns": 4004200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5400, + "serialized_bytes": 612, + "statement_ns": 2310800, + "success": true + }, + { + "mutex_wait_ns": 6270300, + "serialization_ns": 3800, + "serialized_bytes": 610, + "statement_ns": 2655900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4500, + "serialized_bytes": 610, + "statement_ns": 2317500, + "success": true + }, + { + "mutex_wait_ns": 5003400, + "serialization_ns": 6100, + "serialized_bytes": 1038, + "statement_ns": 2362300, + "success": true + }, + { + "mutex_wait_ns": 2375000, + "serialization_ns": 5800, + "serialized_bytes": 1034, + "statement_ns": 2812900, + "success": true + }, + { + "mutex_wait_ns": 2818800, + "serialization_ns": 6800, + "serialized_bytes": 1077, + "statement_ns": 2568600, + "success": true + }, + { + "mutex_wait_ns": 2584100, + "serialization_ns": 5100, + "serialized_bytes": 1073, + "statement_ns": 2314800, + "success": true + }, + { + "mutex_wait_ns": 2331800, + "serialization_ns": 7900, + "serialized_bytes": 1085, + "statement_ns": 2354300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6700, + "serialized_bytes": 1301, + "statement_ns": 3199500, + "success": true + }, + { + "mutex_wait_ns": 5604600, + "serialization_ns": 7200, + "serialized_bytes": 1081, + "statement_ns": 2732900, + "success": true + }, + { + "mutex_wait_ns": 1668800, + "serialization_ns": 3200, + "serialized_bytes": 612, + "statement_ns": 2840100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4500, + "serialized_bytes": 612, + "statement_ns": 2189200, + "success": true + }, + { + "mutex_wait_ns": 5058200, + "serialization_ns": 7300, + "serialized_bytes": 1297, + "statement_ns": 2154600, + "success": true + }, + { + "mutex_wait_ns": 2168900, + "serialization_ns": 5200, + "serialized_bytes": 1038, + "statement_ns": 3011700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5900, + "serialized_bytes": 1077, + "statement_ns": 2667700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6000, + "serialized_bytes": 1085, + "statement_ns": 2402600, + "success": true + }, + { + "mutex_wait_ns": 7678500, + "serialization_ns": 3300, + "serialized_bytes": 610, + "statement_ns": 2817800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5300, + "serialized_bytes": 610, + "statement_ns": 4066400, + "success": true + }, + { + "mutex_wait_ns": 6917400, + "serialization_ns": 6500, + "serialized_bytes": 1301, + "statement_ns": 2445000, + "success": true + }, + { + "mutex_wait_ns": 2457300, + "serialization_ns": 5300, + "serialized_bytes": 1034, + "statement_ns": 2565500, + "success": true + }, + { + "mutex_wait_ns": 2496000, + "serialization_ns": 2800, + "serialized_bytes": 612, + "statement_ns": 2545500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3900, + "serialized_bytes": 612, + "statement_ns": 2569700, + "success": true + }, + { + "mutex_wait_ns": 5141800, + "serialization_ns": 5600, + "serialized_bytes": 1073, + "statement_ns": 2834800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5000, + "serialized_bytes": 1081, + "statement_ns": 2815500, + "success": true + }, + { + "mutex_wait_ns": 5681600, + "serialization_ns": 4900, + "serialized_bytes": 1038, + "statement_ns": 2589300, + "success": true + }, + { + "mutex_wait_ns": 2600300, + "serialization_ns": 6900, + "serialized_bytes": 1297, + "statement_ns": 2241700, + "success": true + }, + { + "mutex_wait_ns": 2253400, + "serialization_ns": 5700, + "serialized_bytes": 1077, + "statement_ns": 2718600, + "success": true + }, + { + "mutex_wait_ns": 2650600, + "serialization_ns": 3400, + "serialized_bytes": 612, + "statement_ns": 2591300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3900, + "serialized_bytes": 612, + "statement_ns": 2343200, + "success": true + }, + { + "mutex_wait_ns": 4969300, + "serialization_ns": 5800, + "serialized_bytes": 1085, + "statement_ns": 2201000, + "success": true + }, + { + "mutex_wait_ns": 2213900, + "serialization_ns": 5400, + "serialized_bytes": 1038, + "statement_ns": 2774000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6200, + "serialized_bytes": 1077, + "statement_ns": 2773700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7900, + "serialized_bytes": 1085, + "statement_ns": 7847500, + "success": true + }, + { + "mutex_wait_ns": 13458600, + "serialization_ns": 6400, + "serialized_bytes": 1301, + "statement_ns": 4184400, + "success": true + }, + { + "mutex_wait_ns": 4194200, + "serialization_ns": 7500, + "serialized_bytes": 1301, + "statement_ns": 2452700, + "success": true + }, + { + "mutex_wait_ns": 2385800, + "serialization_ns": 3000, + "serialized_bytes": 612, + "statement_ns": 3166000, + "success": true + }, + { + "mutex_wait_ns": 3140800, + "serialization_ns": 3100, + "serialized_bytes": 612, + "statement_ns": 2463500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4100, + "serialized_bytes": 612, + "statement_ns": 2270200, + "success": true + }, + { + "mutex_wait_ns": 4764900, + "serialization_ns": 5900, + "serialized_bytes": 612, + "statement_ns": 2537200, + "success": true + }, + { + "mutex_wait_ns": 2550500, + "serialization_ns": 5000, + "serialized_bytes": 1038, + "statement_ns": 2693200, + "success": true + }, + { + "mutex_wait_ns": 2714500, + "serialization_ns": 4200, + "serialized_bytes": 1038, + "statement_ns": 2990500, + "success": true + }, + { + "mutex_wait_ns": 3006600, + "serialization_ns": 4200, + "serialized_bytes": 1077, + "statement_ns": 2585200, + "success": true + }, + { + "mutex_wait_ns": 2589300, + "serialization_ns": 8100, + "serialized_bytes": 1077, + "statement_ns": 2691900, + "success": true + }, + { + "mutex_wait_ns": 2709900, + "serialization_ns": 6000, + "serialized_bytes": 1085, + "statement_ns": 2521100, + "success": true + }, + { + "mutex_wait_ns": 2536400, + "serialization_ns": 8000, + "serialized_bytes": 1085, + "statement_ns": 2465000, + "success": true + }, + { + "mutex_wait_ns": 2466000, + "serialization_ns": 6200, + "serialized_bytes": 1301, + "statement_ns": 2898200, + "success": true + }, + { + "mutex_wait_ns": 2916500, + "serialization_ns": 6500, + "serialized_bytes": 1301, + "statement_ns": 3461300, + "success": true + }, + { + "mutex_wait_ns": 3394000, + "serialization_ns": 2700, + "serialized_bytes": 612, + "statement_ns": 2852000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4400, + "serialized_bytes": 612, + "statement_ns": 2654800, + "success": true + }, + { + "mutex_wait_ns": 5462000, + "serialization_ns": 3600, + "serialized_bytes": 612, + "statement_ns": 3516000, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 4400, + "serialized_bytes": 612, + "statement_ns": 2676500, + "success": true + }, + { + "mutex_wait_ns": 6219300, + "serialization_ns": 5700, + "serialized_bytes": 1038, + "statement_ns": 2687700, + "success": true + }, + { + "mutex_wait_ns": 2704400, + "serialization_ns": 5800, + "serialized_bytes": 1038, + "statement_ns": 2458000, + "success": true + }, + { + "mutex_wait_ns": 2465900, + "serialization_ns": 6000, + "serialized_bytes": 1077, + "statement_ns": 2527000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1085, + "statement_ns": 2664100, + "success": true + }, + { + "mutex_wait_ns": 5218400, + "serialization_ns": 6100, + "serialized_bytes": 1077, + "statement_ns": 5490200, + "success": true + }, + { + "mutex_wait_ns": 5499900, + "serialization_ns": 5800, + "serialized_bytes": 1301, + "statement_ns": 3419100, + "success": true + }, + { + "mutex_wait_ns": 3454700, + "serialization_ns": 6200, + "serialized_bytes": 1085, + "statement_ns": 3336700, + "success": true + }, + { + "mutex_wait_ns": 3286900, + "serialization_ns": 2900, + "serialized_bytes": 610, + "statement_ns": 3659800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4600, + "serialized_bytes": 610, + "statement_ns": 4807600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5800, + "serialized_bytes": 1034, + "statement_ns": 3177800, + "success": true + }, + { + "mutex_wait_ns": 11703900, + "serialization_ns": 9200, + "serialized_bytes": 1301, + "statement_ns": 2809000, + "success": true + }, + { + "mutex_wait_ns": 2820600, + "serialization_ns": 8600, + "serialized_bytes": 1073, + "statement_ns": 4719300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7000, + "serialized_bytes": 1081, + "statement_ns": 2816700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6700, + "serialized_bytes": 1297, + "statement_ns": 3033300, + "success": true + }, + { + "mutex_wait_ns": 10522900, + "serialization_ns": 4200, + "serialized_bytes": 610, + "statement_ns": 3034800, + "success": true + }, + { + "mutex_wait_ns": 2977200, + "serialization_ns": 3000, + "serialized_bytes": 612, + "statement_ns": 3377200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4600, + "serialized_bytes": 612, + "statement_ns": 2501900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1038, + "statement_ns": 2457500, + "success": true + }, + { + "mutex_wait_ns": 8400700, + "serialization_ns": 5600, + "serialized_bytes": 610, + "statement_ns": 2779500, + "success": true + }, + { + "mutex_wait_ns": 2794500, + "serialization_ns": 5200, + "serialized_bytes": 1077, + "statement_ns": 2627200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4700, + "serialized_bytes": 1085, + "statement_ns": 2664900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6200, + "serialized_bytes": 1301, + "statement_ns": 3241700, + "success": true + }, + { + "mutex_wait_ns": 8590100, + "serialization_ns": 4100, + "serialized_bytes": 1034, + "statement_ns": 2436400, + "success": true + }, + { + "mutex_wait_ns": 2363900, + "serialization_ns": 2900, + "serialized_bytes": 610, + "statement_ns": 5337800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5000, + "serialized_bytes": 610, + "statement_ns": 3990000, + "success": true + }, + { + "mutex_wait_ns": 9362400, + "serialization_ns": 6100, + "serialized_bytes": 1073, + "statement_ns": 3394600, + "success": true + }, + { + "mutex_wait_ns": 3417700, + "serialization_ns": 6600, + "serialized_bytes": 1034, + "statement_ns": 3292200, + "success": true + }, + { + "mutex_wait_ns": 3306500, + "serialization_ns": 9700, + "serialized_bytes": 1081, + "statement_ns": 2954500, + "success": true + }, + { + "mutex_wait_ns": 2956400, + "serialization_ns": 8600, + "serialized_bytes": 1073, + "statement_ns": 3117200, + "success": true + }, + { + "mutex_wait_ns": 3127400, + "serialization_ns": 7400, + "serialized_bytes": 1297, + "statement_ns": 2833900, + "success": true + }, + { + "mutex_wait_ns": 2851900, + "serialization_ns": 6800, + "serialized_bytes": 1081, + "statement_ns": 2480600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6600, + "serialized_bytes": 1297, + "statement_ns": 2550800, + "success": true + }, + { + "mutex_wait_ns": 4973500, + "serialization_ns": 3400, + "serialized_bytes": 610, + "statement_ns": 2678900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4600, + "serialized_bytes": 610, + "statement_ns": 2782300, + "success": true + }, + { + "mutex_wait_ns": 5334800, + "serialization_ns": 4300, + "serialized_bytes": 612, + "statement_ns": 3368300, + "success": true + }, + { + "mutex_wait_ns": 400, + "serialization_ns": 4500, + "serialized_bytes": 612, + "statement_ns": 2647000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5600, + "serialized_bytes": 1038, + "statement_ns": 4272900, + "success": true + }, + { + "mutex_wait_ns": 10342400, + "serialization_ns": 6400, + "serialized_bytes": 1034, + "statement_ns": 2523300, + "success": true + }, + { + "mutex_wait_ns": 2530400, + "serialization_ns": 6200, + "serialized_bytes": 1077, + "statement_ns": 3395100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4900, + "serialized_bytes": 1085, + "statement_ns": 2785900, + "success": true + }, + { + "mutex_wait_ns": 6219800, + "serialization_ns": 5900, + "serialized_bytes": 1073, + "statement_ns": 2951700, + "success": true + }, + { + "mutex_wait_ns": 2968100, + "serialization_ns": 7000, + "serialized_bytes": 1301, + "statement_ns": 2548200, + "success": true + }, + { + "mutex_wait_ns": 2573200, + "serialization_ns": 5400, + "serialized_bytes": 1081, + "statement_ns": 2221400, + "success": true + }, + { + "mutex_wait_ns": 2034400, + "serialization_ns": 2900, + "serialized_bytes": 612, + "statement_ns": 3987900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3200, + "serialized_bytes": 612, + "statement_ns": 2365600, + "success": true + }, + { + "mutex_wait_ns": 6382000, + "serialization_ns": 6400, + "serialized_bytes": 1297, + "statement_ns": 2607900, + "success": true + }, + { + "mutex_wait_ns": 2623100, + "serialization_ns": 5000, + "serialized_bytes": 1038, + "statement_ns": 2610400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1077, + "statement_ns": 2320000, + "success": true + }, + { + "mutex_wait_ns": 4884200, + "serialization_ns": 2900, + "serialized_bytes": 612, + "statement_ns": 2947400, + "success": true + }, + { + "mutex_wait_ns": 2965400, + "serialization_ns": 6300, + "serialized_bytes": 1085, + "statement_ns": 2509300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6200, + "serialized_bytes": 1301, + "statement_ns": 2834700, + "success": true + }, + { + "mutex_wait_ns": 5388900, + "serialization_ns": 5400, + "serialized_bytes": 612, + "statement_ns": 3387600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 1038, + "statement_ns": 2530200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6700, + "serialized_bytes": 1077, + "statement_ns": 2326400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6700, + "serialized_bytes": 1085, + "statement_ns": 2630300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6700, + "serialized_bytes": 1301, + "statement_ns": 3897000, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 1784300, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=0", + "COMPILER=msvc-1944", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_W32", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "HTTP", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 561487600, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 266896900, + 266933000, + 266694300, + 266717800, + 266587600, + 266601500, + 266466000, + 266474500, + 266360700, + 266374000, + 266264000, + 266276300, + 266135600, + 266147300, + 266032600, + 519993300, + 518843300, + 519975700, + 519868000, + 519849100, + 519463300, + 519482400, + 519362900, + 519341700, + 519256200, + 519263300, + 519150900, + 553290100, + 552621900, + 553328000, + 553211400, + 559708700 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 258400500, + 243929500, + 23830000, + 309000, + 309800 + ], + "failures": 0, + "in_window_samples": 3, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 258400500, + "end_ns": 269420100, + "in_window": true, + "scheduled_ns": null, + "start_ns": 11019600, + "success": true + }, + { + "elapsed_ns": 243929500, + "end_ns": 523633700, + "in_window": true, + "scheduled_ns": null, + "start_ns": 279704200, + "success": true + }, + { + "elapsed_ns": 23830000, + "end_ns": 557570600, + "in_window": true, + "scheduled_ns": null, + "start_ns": 533740600, + "success": true + }, + { + "elapsed_ns": 309000, + "end_ns": 567976100, + "in_window": false, + "scheduled_ns": null, + "start_ns": 567667100, + "success": true + }, + { + "elapsed_ns": 309800, + "end_ns": 578444800, + "in_window": false, + "scheduled_ns": null, + "start_ns": 578135000, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 256783900, + 221087800, + 54827100, + 1421000, + 5695300, + 3730700, + 9836500 + ], + "failures": 0, + "in_window_samples": 4, + "missed_periods": 52, + "samples": [ + { + "elapsed_ns": 256783900, + "end_ns": 269215300, + "in_window": true, + "scheduled_ns": 12431400, + "start_ns": 269215300, + "success": true + }, + { + "elapsed_ns": 221087800, + "end_ns": 493519200, + "in_window": true, + "scheduled_ns": 272431400, + "start_ns": 493519200, + "success": true + }, + { + "elapsed_ns": 54827100, + "end_ns": 557258500, + "in_window": true, + "scheduled_ns": 502431400, + "start_ns": 557258500, + "success": true + }, + { + "elapsed_ns": 1421000, + "end_ns": 563852400, + "in_window": true, + "scheduled_ns": 562431400, + "start_ns": 563852400, + "success": true + }, + { + "elapsed_ns": 5695300, + "end_ns": 578126700, + "in_window": false, + "scheduled_ns": 572431400, + "start_ns": 578126700, + "success": true + }, + { + "elapsed_ns": 3730700, + "end_ns": 586162100, + "in_window": false, + "scheduled_ns": 582431400, + "start_ns": 586162100, + "success": true + }, + { + "elapsed_ns": 9836500, + "end_ns": 602267900, + "in_window": false, + "scheduled_ns": 592431400, + "start_ns": 602267900, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 563940300, + "window_start_ns": 2452700 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 2, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 0, + "serialization_ns": 6500, + "serialized_bytes": 612, + "statement_ns": 2759100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4000, + "serialized_bytes": 612, + "statement_ns": 2275600, + "success": true + }, + { + "mutex_wait_ns": 4768300, + "serialization_ns": 14700, + "serialized_bytes": 612, + "statement_ns": 2922000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4800, + "serialized_bytes": 612, + "statement_ns": 2386000, + "success": true + }, + { + "mutex_wait_ns": 5337300, + "serialization_ns": 6200, + "serialized_bytes": 1038, + "statement_ns": 2317800, + "success": true + }, + { + "mutex_wait_ns": 2332700, + "serialization_ns": 5900, + "serialized_bytes": 1038, + "statement_ns": 2422300, + "success": true + }, + { + "mutex_wait_ns": 2426800, + "serialization_ns": 7400, + "serialized_bytes": 1077, + "statement_ns": 2940900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 1085, + "statement_ns": 2640900, + "success": true + }, + { + "mutex_wait_ns": 5607900, + "serialization_ns": 6700, + "serialized_bytes": 1077, + "statement_ns": 2618500, + "success": true + }, + { + "mutex_wait_ns": 2624100, + "serialization_ns": 6600, + "serialized_bytes": 1301, + "statement_ns": 2414700, + "success": true + }, + { + "mutex_wait_ns": 2422400, + "serialization_ns": 5500, + "serialized_bytes": 1085, + "statement_ns": 3462100, + "success": true + }, + { + "mutex_wait_ns": 3186800, + "serialization_ns": 3300, + "serialized_bytes": 612, + "statement_ns": 2567800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4000, + "serialized_bytes": 612, + "statement_ns": 2333500, + "success": true + }, + { + "mutex_wait_ns": 4925500, + "serialization_ns": 9100, + "serialized_bytes": 1301, + "statement_ns": 2307800, + "success": true + }, + { + "mutex_wait_ns": 2326200, + "serialization_ns": 4800, + "serialized_bytes": 1038, + "statement_ns": 2726400, + "success": true + }, + { + "mutex_wait_ns": 2647300, + "serialization_ns": 2900, + "serialized_bytes": 612, + "statement_ns": 3810400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5000, + "serialized_bytes": 612, + "statement_ns": 2645100, + "success": true + }, + { + "mutex_wait_ns": 6477700, + "serialization_ns": 9100, + "serialized_bytes": 1077, + "statement_ns": 2651100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5000, + "serialized_bytes": 1085, + "statement_ns": 2728200, + "success": true + }, + { + "mutex_wait_ns": 5408500, + "serialization_ns": 4800, + "serialized_bytes": 1038, + "statement_ns": 2747400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1077, + "statement_ns": 2771100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1085, + "statement_ns": 2431900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6300, + "serialized_bytes": 1301, + "statement_ns": 2352600, + "success": true + }, + { + "mutex_wait_ns": 10396900, + "serialization_ns": 6800, + "serialized_bytes": 1301, + "statement_ns": 3588400, + "success": true + }, + { + "mutex_wait_ns": 3514600, + "serialization_ns": 3100, + "serialized_bytes": 610, + "statement_ns": 2569600, + "success": true + }, + { + "mutex_wait_ns": 300, + "serialization_ns": 3900, + "serialized_bytes": 610, + "statement_ns": 2267200, + "success": true + }, + { + "mutex_wait_ns": 4787100, + "serialization_ns": 4600, + "serialized_bytes": 612, + "statement_ns": 3134700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5000, + "serialized_bytes": 612, + "statement_ns": 2339500, + "success": true + }, + { + "mutex_wait_ns": 5506000, + "serialization_ns": 4800, + "serialized_bytes": 1034, + "statement_ns": 2576500, + "success": true + }, + { + "mutex_wait_ns": 2589200, + "serialization_ns": 5000, + "serialized_bytes": 1038, + "statement_ns": 3555400, + "success": true + }, + { + "mutex_wait_ns": 3564600, + "serialization_ns": 4900, + "serialized_bytes": 1073, + "statement_ns": 3011400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4800, + "serialized_bytes": 1081, + "statement_ns": 2360900, + "success": true + }, + { + "mutex_wait_ns": 5407800, + "serialization_ns": 5100, + "serialized_bytes": 1077, + "statement_ns": 3124500, + "success": true + }, + { + "mutex_wait_ns": 3139800, + "serialization_ns": 6300, + "serialized_bytes": 1297, + "statement_ns": 3216900, + "success": true + }, + { + "mutex_wait_ns": 3237200, + "serialization_ns": 5400, + "serialized_bytes": 1085, + "statement_ns": 4347200, + "success": true + }, + { + "mutex_wait_ns": 4246300, + "serialization_ns": 4200, + "serialized_bytes": 612, + "statement_ns": 3385500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3800, + "serialized_bytes": 612, + "statement_ns": 2209500, + "success": true + }, + { + "mutex_wait_ns": 5617500, + "serialization_ns": 9700, + "serialized_bytes": 1301, + "statement_ns": 2304100, + "success": true + }, + { + "mutex_wait_ns": 2316600, + "serialization_ns": 6100, + "serialized_bytes": 1038, + "statement_ns": 2330100, + "success": true + }, + { + "mutex_wait_ns": 2245200, + "serialization_ns": 2800, + "serialized_bytes": 610, + "statement_ns": 3864200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6100, + "serialized_bytes": 610, + "statement_ns": 2354800, + "success": true + }, + { + "mutex_wait_ns": 6249300, + "serialization_ns": 6700, + "serialized_bytes": 1077, + "statement_ns": 2443100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5600, + "serialized_bytes": 1085, + "statement_ns": 2508300, + "success": true + }, + { + "mutex_wait_ns": 4981400, + "serialization_ns": 5600, + "serialized_bytes": 1034, + "statement_ns": 4052900, + "success": true + }, + { + "mutex_wait_ns": 4063600, + "serialization_ns": 5500, + "serialized_bytes": 1301, + "statement_ns": 4483200, + "success": true + }, + { + "mutex_wait_ns": 4498900, + "serialization_ns": 5200, + "serialized_bytes": 1073, + "statement_ns": 2586200, + "success": true + }, + { + "mutex_wait_ns": 2495300, + "serialization_ns": 3700, + "serialized_bytes": 612, + "statement_ns": 2647400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5100, + "serialized_bytes": 612, + "statement_ns": 3423800, + "success": true + }, + { + "mutex_wait_ns": 6109100, + "serialization_ns": 11000, + "serialized_bytes": 1081, + "statement_ns": 2402100, + "success": true + }, + { + "mutex_wait_ns": 2416200, + "serialization_ns": 6300, + "serialized_bytes": 1038, + "statement_ns": 2445900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1077, + "statement_ns": 2586700, + "success": true + }, + { + "mutex_wait_ns": 5075600, + "serialization_ns": 7100, + "serialized_bytes": 1297, + "statement_ns": 2490400, + "success": true + }, + { + "mutex_wait_ns": 2519500, + "serialization_ns": 8000, + "serialized_bytes": 1085, + "statement_ns": 2308600, + "success": true + }, + { + "mutex_wait_ns": 2217000, + "serialization_ns": 3900, + "serialized_bytes": 612, + "statement_ns": 3460800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4900, + "serialized_bytes": 612, + "statement_ns": 2733300, + "success": true + }, + { + "mutex_wait_ns": 6222900, + "serialization_ns": 9100, + "serialized_bytes": 1301, + "statement_ns": 2782000, + "success": true + }, + { + "mutex_wait_ns": 2800000, + "serialization_ns": 5100, + "serialized_bytes": 1038, + "statement_ns": 2401500, + "success": true + }, + { + "mutex_wait_ns": 2317500, + "serialization_ns": 3600, + "serialized_bytes": 612, + "statement_ns": 2684600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4200, + "serialized_bytes": 612, + "statement_ns": 2273300, + "success": true + }, + { + "mutex_wait_ns": 4984600, + "serialization_ns": 8500, + "serialized_bytes": 1077, + "statement_ns": 2494000, + "success": true + }, + { + "mutex_wait_ns": 2506600, + "serialization_ns": 5500, + "serialized_bytes": 1038, + "statement_ns": 2674600, + "success": true + }, + { + "mutex_wait_ns": 2692200, + "serialization_ns": 6100, + "serialized_bytes": 1085, + "statement_ns": 3070600, + "success": true + }, + { + "mutex_wait_ns": 3082000, + "serialization_ns": 5600, + "serialized_bytes": 1077, + "statement_ns": 2478200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6200, + "serialized_bytes": 1085, + "statement_ns": 2899600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5900, + "serialized_bytes": 1301, + "statement_ns": 2642500, + "success": true + }, + { + "mutex_wait_ns": 8076500, + "serialization_ns": 5100, + "serialized_bytes": 1301, + "statement_ns": 3256600, + "success": true + }, + { + "mutex_wait_ns": 3175300, + "serialization_ns": 3100, + "serialized_bytes": 610, + "statement_ns": 4164600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4800, + "serialized_bytes": 610, + "statement_ns": 2665100, + "success": true + }, + { + "mutex_wait_ns": 6792400, + "serialization_ns": 4500, + "serialized_bytes": 612, + "statement_ns": 3093700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4800, + "serialized_bytes": 612, + "statement_ns": 2562400, + "success": true + }, + { + "mutex_wait_ns": 5684700, + "serialization_ns": 5800, + "serialized_bytes": 1034, + "statement_ns": 3472100, + "success": true + }, + { + "mutex_wait_ns": 3484800, + "serialization_ns": 5300, + "serialized_bytes": 1038, + "statement_ns": 3800800, + "success": true + }, + { + "mutex_wait_ns": 3809400, + "serialization_ns": 5600, + "serialized_bytes": 1073, + "statement_ns": 3005500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1081, + "statement_ns": 2274100, + "success": true + }, + { + "mutex_wait_ns": 5309300, + "serialization_ns": 5800, + "serialized_bytes": 1077, + "statement_ns": 2268500, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 4400, + "serialized_bytes": 1085, + "statement_ns": 2246000, + "success": true + }, + { + "mutex_wait_ns": 4550800, + "serialization_ns": 5500, + "serialized_bytes": 1297, + "statement_ns": 2190400, + "success": true + }, + { + "mutex_wait_ns": 2206900, + "serialization_ns": 7000, + "serialized_bytes": 1301, + "statement_ns": 3460700, + "success": true + }, + { + "mutex_wait_ns": 3374800, + "serialization_ns": 3300, + "serialized_bytes": 610, + "statement_ns": 3474200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4500, + "serialized_bytes": 610, + "statement_ns": 3216200, + "success": true + }, + { + "mutex_wait_ns": 6585000, + "serialization_ns": 4400, + "serialized_bytes": 610, + "statement_ns": 3052000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4900, + "serialized_bytes": 610, + "statement_ns": 2457200, + "success": true + }, + { + "mutex_wait_ns": 5541700, + "serialization_ns": 4700, + "serialized_bytes": 1034, + "statement_ns": 2638100, + "success": true + }, + { + "mutex_wait_ns": 2653800, + "serialization_ns": 5100, + "serialized_bytes": 1034, + "statement_ns": 2281600, + "success": true + }, + { + "mutex_wait_ns": 2289400, + "serialization_ns": 6100, + "serialized_bytes": 1073, + "statement_ns": 3853800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1081, + "statement_ns": 3865100, + "success": true + }, + { + "mutex_wait_ns": 7751400, + "serialization_ns": 5100, + "serialized_bytes": 1073, + "statement_ns": 2965500, + "success": true + }, + { + "mutex_wait_ns": 2976000, + "serialization_ns": 6200, + "serialized_bytes": 1297, + "statement_ns": 3182100, + "success": true + }, + { + "mutex_wait_ns": 3202500, + "serialization_ns": 5600, + "serialized_bytes": 1081, + "statement_ns": 4238800, + "success": true + }, + { + "mutex_wait_ns": 4120400, + "serialization_ns": 3400, + "serialized_bytes": 612, + "statement_ns": 2562400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3500, + "serialized_bytes": 612, + "statement_ns": 2265900, + "success": true + }, + { + "mutex_wait_ns": 4854800, + "serialization_ns": 8400, + "serialized_bytes": 1297, + "statement_ns": 2480300, + "success": true + }, + { + "mutex_wait_ns": 2500100, + "serialization_ns": 5600, + "serialized_bytes": 1038, + "statement_ns": 2469900, + "success": true + }, + { + "mutex_wait_ns": 1147000, + "serialization_ns": 3300, + "serialized_bytes": 612, + "statement_ns": 4455000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4500, + "serialized_bytes": 612, + "statement_ns": 2862700, + "success": true + }, + { + "mutex_wait_ns": 7344300, + "serialization_ns": 7300, + "serialized_bytes": 1077, + "statement_ns": 2813900, + "success": true + }, + { + "mutex_wait_ns": 2829200, + "serialization_ns": 5400, + "serialized_bytes": 1038, + "statement_ns": 2533300, + "success": true + }, + { + "mutex_wait_ns": 2555500, + "serialization_ns": 6700, + "serialized_bytes": 1085, + "statement_ns": 2974500, + "success": true + }, + { + "mutex_wait_ns": 2989600, + "serialization_ns": 7100, + "serialized_bytes": 1077, + "statement_ns": 2702200, + "success": true + }, + { + "mutex_wait_ns": 2712400, + "serialization_ns": 6700, + "serialized_bytes": 1301, + "statement_ns": 2538000, + "success": true + }, + { + "mutex_wait_ns": 2554400, + "serialization_ns": 6600, + "serialized_bytes": 1085, + "statement_ns": 2606700, + "success": true + }, + { + "mutex_wait_ns": 2535400, + "serialization_ns": 3200, + "serialized_bytes": 610, + "statement_ns": 2929500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3700, + "serialized_bytes": 610, + "statement_ns": 3237700, + "success": true + }, + { + "mutex_wait_ns": 6196200, + "serialization_ns": 7900, + "serialized_bytes": 1301, + "statement_ns": 4286400, + "success": true + }, + { + "mutex_wait_ns": 4300900, + "serialization_ns": 5100, + "serialized_bytes": 1034, + "statement_ns": 2325500, + "success": true + }, + { + "mutex_wait_ns": 2254400, + "serialization_ns": 4000, + "serialized_bytes": 610, + "statement_ns": 2873800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4900, + "serialized_bytes": 610, + "statement_ns": 2333100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1034, + "statement_ns": 2245200, + "success": true + }, + { + "mutex_wait_ns": 7500300, + "serialization_ns": 7300, + "serialized_bytes": 1073, + "statement_ns": 2259200, + "success": true + }, + { + "mutex_wait_ns": 2273700, + "serialization_ns": 5800, + "serialized_bytes": 1073, + "statement_ns": 2243700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1081, + "statement_ns": 3236700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 1297, + "statement_ns": 2312400, + "success": true + }, + { + "mutex_wait_ns": 7850700, + "serialization_ns": 7100, + "serialized_bytes": 1081, + "statement_ns": 2389300, + "success": true + }, + { + "mutex_wait_ns": 2317200, + "serialization_ns": 5700, + "serialized_bytes": 612, + "statement_ns": 2748700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4600, + "serialized_bytes": 612, + "statement_ns": 2289600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4400, + "serialized_bytes": 1038, + "statement_ns": 5111400, + "success": true + }, + { + "mutex_wait_ns": 10196300, + "serialization_ns": 10800, + "serialized_bytes": 1297, + "statement_ns": 3054900, + "success": true + }, + { + "mutex_wait_ns": 3072200, + "serialization_ns": 5100, + "serialized_bytes": 1077, + "statement_ns": 3079600, + "success": true + }, + { + "mutex_wait_ns": 2988100, + "serialization_ns": 3900, + "serialized_bytes": 612, + "statement_ns": 2884900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 612, + "statement_ns": 3780800, + "success": true + }, + { + "mutex_wait_ns": 6699000, + "serialization_ns": 9700, + "serialized_bytes": 1085, + "statement_ns": 2470800, + "success": true + }, + { + "mutex_wait_ns": 2478700, + "serialization_ns": 6700, + "serialized_bytes": 1038, + "statement_ns": 2557000, + "success": true + }, + { + "mutex_wait_ns": 2567200, + "serialization_ns": 6600, + "serialized_bytes": 1301, + "statement_ns": 2608500, + "success": true + }, + { + "mutex_wait_ns": 2616700, + "serialization_ns": 6300, + "serialized_bytes": 1077, + "statement_ns": 3020600, + "success": true + }, + { + "mutex_wait_ns": 2943400, + "serialization_ns": 3200, + "serialized_bytes": 612, + "statement_ns": 2683100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5100, + "serialized_bytes": 612, + "statement_ns": 2895400, + "success": true + }, + { + "mutex_wait_ns": 5612800, + "serialization_ns": 9400, + "serialized_bytes": 1085, + "statement_ns": 2637200, + "success": true + }, + { + "mutex_wait_ns": 2651800, + "serialization_ns": 5900, + "serialized_bytes": 1038, + "statement_ns": 3042800, + "success": true + }, + { + "mutex_wait_ns": 3052000, + "serialization_ns": 7900, + "serialized_bytes": 1301, + "statement_ns": 2733000, + "success": true + }, + { + "mutex_wait_ns": 2745800, + "serialization_ns": 6000, + "serialized_bytes": 1077, + "statement_ns": 2839300, + "success": true + }, + { + "mutex_wait_ns": 2755800, + "serialization_ns": 3900, + "serialized_bytes": 612, + "statement_ns": 2698800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4200, + "serialized_bytes": 612, + "statement_ns": 2959500, + "success": true + }, + { + "mutex_wait_ns": 5690100, + "serialization_ns": 8200, + "serialized_bytes": 1085, + "statement_ns": 2514400, + "success": true + }, + { + "mutex_wait_ns": 2524500, + "serialization_ns": 6900, + "serialized_bytes": 1038, + "statement_ns": 2588000, + "success": true + }, + { + "mutex_wait_ns": 2600000, + "serialization_ns": 5800, + "serialized_bytes": 1301, + "statement_ns": 2622000, + "success": true + }, + { + "mutex_wait_ns": 2637100, + "serialization_ns": 5700, + "serialized_bytes": 1077, + "statement_ns": 2633200, + "success": true + }, + { + "mutex_wait_ns": 2559600, + "serialization_ns": 3800, + "serialized_bytes": 610, + "statement_ns": 4565700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 610, + "statement_ns": 2841900, + "success": true + }, + { + "mutex_wait_ns": 7445300, + "serialization_ns": 8300, + "serialized_bytes": 1085, + "statement_ns": 5215400, + "success": true + }, + { + "mutex_wait_ns": 5231300, + "serialization_ns": 5300, + "serialized_bytes": 1034, + "statement_ns": 3107300, + "success": true + }, + { + "mutex_wait_ns": 3112800, + "serialization_ns": 7800, + "serialized_bytes": 1301, + "statement_ns": 4483300, + "success": true + }, + { + "mutex_wait_ns": 4494200, + "serialization_ns": 6400, + "serialized_bytes": 1073, + "statement_ns": 2502400, + "success": true + }, + { + "mutex_wait_ns": 2418600, + "serialization_ns": 3700, + "serialized_bytes": 612, + "statement_ns": 2667700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3600, + "serialized_bytes": 612, + "statement_ns": 2550500, + "success": true + }, + { + "mutex_wait_ns": 5248400, + "serialization_ns": 7800, + "serialized_bytes": 1081, + "statement_ns": 2285900, + "success": true + }, + { + "mutex_wait_ns": 2297400, + "serialization_ns": 5600, + "serialized_bytes": 1038, + "statement_ns": 2715700, + "success": true + }, + { + "mutex_wait_ns": 2725800, + "serialization_ns": 7000, + "serialized_bytes": 1297, + "statement_ns": 4006900, + "success": true + }, + { + "mutex_wait_ns": 4024000, + "serialization_ns": 5000, + "serialized_bytes": 1077, + "statement_ns": 2573200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7900, + "serialized_bytes": 1085, + "statement_ns": 2555700, + "success": true + }, + { + "mutex_wait_ns": 5079700, + "serialization_ns": 4300, + "serialized_bytes": 612, + "statement_ns": 2708800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4700, + "serialized_bytes": 612, + "statement_ns": 2295300, + "success": true + }, + { + "mutex_wait_ns": 5038100, + "serialization_ns": 7400, + "serialized_bytes": 1301, + "statement_ns": 3803100, + "success": true + }, + { + "mutex_wait_ns": 3819500, + "serialization_ns": 5300, + "serialized_bytes": 1038, + "statement_ns": 3684700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7300, + "serialized_bytes": 1077, + "statement_ns": 2406600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6700, + "serialized_bytes": 1085, + "statement_ns": 2773900, + "success": true + }, + { + "mutex_wait_ns": 8848100, + "serialization_ns": 3300, + "serialized_bytes": 612, + "statement_ns": 3386500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4100, + "serialized_bytes": 612, + "statement_ns": 2629400, + "success": true + }, + { + "mutex_wait_ns": 6044700, + "serialization_ns": 6800, + "serialized_bytes": 1301, + "statement_ns": 3293400, + "success": true + }, + { + "mutex_wait_ns": 3305800, + "serialization_ns": 5300, + "serialized_bytes": 1038, + "statement_ns": 3626600, + "success": true + }, + { + "mutex_wait_ns": 3560800, + "serialization_ns": 3300, + "serialized_bytes": 612, + "statement_ns": 3010400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4800, + "serialized_bytes": 612, + "statement_ns": 2678000, + "success": true + }, + { + "mutex_wait_ns": 5715100, + "serialization_ns": 7800, + "serialized_bytes": 1077, + "statement_ns": 2673400, + "success": true + }, + { + "mutex_wait_ns": 2688200, + "serialization_ns": 5700, + "serialized_bytes": 1038, + "statement_ns": 2462800, + "success": true + }, + { + "mutex_wait_ns": 2478700, + "serialization_ns": 6400, + "serialized_bytes": 1085, + "statement_ns": 2557400, + "success": true + }, + { + "mutex_wait_ns": 2568800, + "serialization_ns": 5700, + "serialized_bytes": 1077, + "statement_ns": 2936300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4800, + "serialized_bytes": 1085, + "statement_ns": 5672700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6200, + "serialized_bytes": 1301, + "statement_ns": 3253200, + "success": true + }, + { + "mutex_wait_ns": 11920200, + "serialization_ns": 5900, + "serialized_bytes": 1301, + "statement_ns": 3444400, + "success": true + }, + { + "mutex_wait_ns": 3269100, + "serialization_ns": 3300, + "serialized_bytes": 612, + "statement_ns": 2657000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5100, + "serialized_bytes": 612, + "statement_ns": 2772200, + "success": true + }, + { + "mutex_wait_ns": 5395600, + "serialization_ns": 5100, + "serialized_bytes": 610, + "statement_ns": 3310600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4300, + "serialized_bytes": 610, + "statement_ns": 2386700, + "success": true + }, + { + "mutex_wait_ns": 5729000, + "serialization_ns": 5800, + "serialized_bytes": 1038, + "statement_ns": 4141900, + "success": true + }, + { + "mutex_wait_ns": 4154700, + "serialization_ns": 5700, + "serialized_bytes": 1034, + "statement_ns": 2532800, + "success": true + }, + { + "mutex_wait_ns": 2544200, + "serialization_ns": 5600, + "serialized_bytes": 1077, + "statement_ns": 2958100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4900, + "serialized_bytes": 1085, + "statement_ns": 2466000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7300, + "serialized_bytes": 1301, + "statement_ns": 3179500, + "success": true + }, + { + "mutex_wait_ns": 8662100, + "serialization_ns": 4900, + "serialized_bytes": 1073, + "statement_ns": 3292400, + "success": true + }, + { + "mutex_wait_ns": 2797200, + "serialization_ns": 3300, + "serialized_bytes": 612, + "statement_ns": 2578900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6500, + "serialized_bytes": 612, + "statement_ns": 2791700, + "success": true + }, + { + "mutex_wait_ns": 5409100, + "serialization_ns": 8100, + "serialized_bytes": 1081, + "statement_ns": 2437100, + "success": true + }, + { + "mutex_wait_ns": 2452000, + "serialization_ns": 6200, + "serialized_bytes": 1038, + "statement_ns": 2779400, + "success": true + }, + { + "mutex_wait_ns": 2797300, + "serialization_ns": 6500, + "serialized_bytes": 1297, + "statement_ns": 2512700, + "success": true + }, + { + "mutex_wait_ns": 2524900, + "serialization_ns": 8000, + "serialized_bytes": 1077, + "statement_ns": 3124600, + "success": true + }, + { + "mutex_wait_ns": 3076800, + "serialization_ns": 3500, + "serialized_bytes": 610, + "statement_ns": 3151000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4200, + "serialized_bytes": 610, + "statement_ns": 2533900, + "success": true + }, + { + "mutex_wait_ns": 5723900, + "serialization_ns": 9300, + "serialized_bytes": 1085, + "statement_ns": 2717300, + "success": true + }, + { + "mutex_wait_ns": 2737200, + "serialization_ns": 6000, + "serialized_bytes": 1034, + "statement_ns": 2740600, + "success": true + }, + { + "mutex_wait_ns": 2757500, + "serialization_ns": 6700, + "serialized_bytes": 1301, + "statement_ns": 2787300, + "success": true + }, + { + "mutex_wait_ns": 2806000, + "serialization_ns": 5000, + "serialized_bytes": 1073, + "statement_ns": 2274300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7100, + "serialized_bytes": 1081, + "statement_ns": 2061300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6200, + "serialized_bytes": 1297, + "statement_ns": 2310300, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 1961200, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=0", + "COMPILER=msvc-1944", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_W32", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "HTTP", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 624496700, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 125771400, + 124128500, + 516266000, + 550315600, + 551671000, + 552795500, + 551740100, + 552857500, + 551652400, + 551701000, + 551573000, + 551599700, + 552430000, + 582738900, + 583992100, + 582906600, + 584058200, + 582973200, + 583808700, + 582758200, + 583864600, + 582655400, + 583763000, + 582712400, + 582092900, + 583487400, + 582162000, + 582052700, + 582404800, + 612764000, + 611889000, + 623103600 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 1933600, + 38053400, + 28340600, + 416582800, + 57147500, + 19766600, + 450800, + 401900, + 274500 + ], + "failures": 0, + "in_window_samples": 6, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 1933600, + "end_ns": 12977500, + "in_window": true, + "scheduled_ns": null, + "start_ns": 11043900, + "success": true + }, + { + "elapsed_ns": 38053400, + "end_ns": 61303600, + "in_window": true, + "scheduled_ns": null, + "start_ns": 23250200, + "success": true + }, + { + "elapsed_ns": 28340600, + "end_ns": 99761900, + "in_window": true, + "scheduled_ns": null, + "start_ns": 71421300, + "success": true + }, + { + "elapsed_ns": 416582800, + "end_ns": 526820900, + "in_window": true, + "scheduled_ns": null, + "start_ns": 110238100, + "success": true + }, + { + "elapsed_ns": 57147500, + "end_ns": 594105000, + "in_window": true, + "scheduled_ns": null, + "start_ns": 536957500, + "success": true + }, + { + "elapsed_ns": 19766600, + "end_ns": 624021900, + "in_window": true, + "scheduled_ns": null, + "start_ns": 604255300, + "success": true + }, + { + "elapsed_ns": 450800, + "end_ns": 634568600, + "in_window": false, + "scheduled_ns": null, + "start_ns": 634117800, + "success": true + }, + { + "elapsed_ns": 401900, + "end_ns": 645123100, + "in_window": false, + "scheduled_ns": null, + "start_ns": 644721200, + "success": true + }, + { + "elapsed_ns": 274500, + "end_ns": 655555900, + "in_window": false, + "scheduled_ns": null, + "start_ns": 655281400, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 38436100, + 3170300, + 29826500, + 401081600, + 84064300, + 24206700, + 4399000, + 5488400, + 5833200, + 11635400 + ], + "failures": 0, + "in_window_samples": 7, + "missed_periods": 56, + "samples": [ + { + "elapsed_ns": 38436100, + "end_ns": 57921100, + "in_window": true, + "scheduled_ns": 19485000, + "start_ns": 57921100, + "success": true + }, + { + "elapsed_ns": 3170300, + "end_ns": 62655300, + "in_window": true, + "scheduled_ns": 59485000, + "start_ns": 62655300, + "success": true + }, + { + "elapsed_ns": 29826500, + "end_ns": 99311500, + "in_window": true, + "scheduled_ns": 69485000, + "start_ns": 99311500, + "success": true + }, + { + "elapsed_ns": 401081600, + "end_ns": 500566600, + "in_window": true, + "scheduled_ns": 99485000, + "start_ns": 500566600, + "success": true + }, + { + "elapsed_ns": 84064300, + "end_ns": 593549300, + "in_window": true, + "scheduled_ns": 509485000, + "start_ns": 593549300, + "success": true + }, + { + "elapsed_ns": 24206700, + "end_ns": 623691700, + "in_window": true, + "scheduled_ns": 599485000, + "start_ns": 623691700, + "success": true + }, + { + "elapsed_ns": 4399000, + "end_ns": 633884000, + "in_window": true, + "scheduled_ns": 629485000, + "start_ns": 633884000, + "success": true + }, + { + "elapsed_ns": 5488400, + "end_ns": 644973400, + "in_window": false, + "scheduled_ns": 639485000, + "start_ns": 644973400, + "success": true + }, + { + "elapsed_ns": 5833200, + "end_ns": 655318200, + "in_window": false, + "scheduled_ns": 649485000, + "start_ns": 655318200, + "success": true + }, + { + "elapsed_ns": 11635400, + "end_ns": 671120400, + "in_window": false, + "scheduled_ns": 659485000, + "start_ns": 671120400, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 634005000, + "window_start_ns": 9508300 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 0, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 200, + "serialization_ns": 4700, + "serialized_bytes": 613, + "statement_ns": 3203300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4400, + "serialized_bytes": 613, + "statement_ns": 2734800, + "success": true + }, + { + "mutex_wait_ns": 5249700, + "serialization_ns": 4000, + "serialized_bytes": 611, + "statement_ns": 3335200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5500, + "serialized_bytes": 611, + "statement_ns": 3083800, + "success": true + }, + { + "mutex_wait_ns": 6450000, + "serialization_ns": 6300, + "serialized_bytes": 1040, + "statement_ns": 3119100, + "success": true + }, + { + "mutex_wait_ns": 3131400, + "serialization_ns": 6800, + "serialized_bytes": 1036, + "statement_ns": 2669200, + "success": true + }, + { + "mutex_wait_ns": 2670800, + "serialization_ns": 6800, + "serialized_bytes": 1079, + "statement_ns": 2425300, + "success": true + }, + { + "mutex_wait_ns": 2435900, + "serialization_ns": 5900, + "serialized_bytes": 1075, + "statement_ns": 2763400, + "success": true + }, + { + "mutex_wait_ns": 2779900, + "serialization_ns": 6500, + "serialized_bytes": 1087, + "statement_ns": 2526700, + "success": true + }, + { + "mutex_wait_ns": 2545900, + "serialization_ns": 6000, + "serialized_bytes": 1083, + "statement_ns": 3758100, + "success": true + }, + { + "mutex_wait_ns": 3770200, + "serialization_ns": 6500, + "serialized_bytes": 1303, + "statement_ns": 2661800, + "success": true + }, + { + "mutex_wait_ns": 2673200, + "serialization_ns": 7000, + "serialized_bytes": 1299, + "statement_ns": 2757000, + "success": true + }, + { + "mutex_wait_ns": 1638100, + "serialization_ns": 3300, + "serialized_bytes": 611, + "statement_ns": 3260400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4400, + "serialized_bytes": 611, + "statement_ns": 2433500, + "success": true + }, + { + "mutex_wait_ns": 5594300, + "serialization_ns": 3600, + "serialized_bytes": 613, + "statement_ns": 4566600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4800, + "serialized_bytes": 613, + "statement_ns": 2688300, + "success": true + }, + { + "mutex_wait_ns": 7291700, + "serialization_ns": 5400, + "serialized_bytes": 1036, + "statement_ns": 2638400, + "success": true + }, + { + "mutex_wait_ns": 2656500, + "serialization_ns": 6900, + "serialized_bytes": 1040, + "statement_ns": 3855000, + "success": true + }, + { + "mutex_wait_ns": 3866200, + "serialization_ns": 6900, + "serialized_bytes": 1075, + "statement_ns": 2746000, + "success": true + }, + { + "mutex_wait_ns": 2759400, + "serialization_ns": 6500, + "serialized_bytes": 1079, + "statement_ns": 3086500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7800, + "serialized_bytes": 1087, + "statement_ns": 2711100, + "success": true + }, + { + "mutex_wait_ns": 5839100, + "serialization_ns": 5500, + "serialized_bytes": 1083, + "statement_ns": 2919600, + "success": true + }, + { + "mutex_wait_ns": 2931500, + "serialization_ns": 7000, + "serialized_bytes": 1303, + "statement_ns": 3467600, + "success": true + }, + { + "mutex_wait_ns": 3479000, + "serialization_ns": 6800, + "serialized_bytes": 1299, + "statement_ns": 3192200, + "success": true + }, + { + "mutex_wait_ns": 2894600, + "serialization_ns": 3300, + "serialized_bytes": 613, + "statement_ns": 4018400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4200, + "serialized_bytes": 613, + "statement_ns": 2464300, + "success": true + }, + { + "mutex_wait_ns": 6378200, + "serialization_ns": 3200, + "serialized_bytes": 613, + "statement_ns": 3139000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4400, + "serialized_bytes": 613, + "statement_ns": 2621400, + "success": true + }, + { + "mutex_wait_ns": 5792700, + "serialization_ns": 5900, + "serialized_bytes": 1040, + "statement_ns": 3912000, + "success": true + }, + { + "mutex_wait_ns": 3932000, + "serialization_ns": 5300, + "serialized_bytes": 1040, + "statement_ns": 2627500, + "success": true + }, + { + "mutex_wait_ns": 2635500, + "serialization_ns": 6900, + "serialized_bytes": 1079, + "statement_ns": 2892100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6100, + "serialized_bytes": 1087, + "statement_ns": 2526400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7000, + "serialized_bytes": 1303, + "statement_ns": 3000300, + "success": true + }, + { + "mutex_wait_ns": 8499000, + "serialization_ns": 6400, + "serialized_bytes": 1079, + "statement_ns": 2755500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6500, + "serialized_bytes": 1087, + "statement_ns": 2687800, + "success": true + }, + { + "mutex_wait_ns": 4604700, + "serialization_ns": 3400, + "serialized_bytes": 611, + "statement_ns": 3258100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3900, + "serialized_bytes": 611, + "statement_ns": 2788100, + "success": true + }, + { + "mutex_wait_ns": 6083100, + "serialization_ns": 7600, + "serialized_bytes": 1303, + "statement_ns": 2698300, + "success": true + }, + { + "mutex_wait_ns": 2719700, + "serialization_ns": 5400, + "serialized_bytes": 1036, + "statement_ns": 2995100, + "success": true + }, + { + "mutex_wait_ns": 2794500, + "serialization_ns": 4000, + "serialized_bytes": 611, + "statement_ns": 3345800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6400, + "serialized_bytes": 611, + "statement_ns": 2819100, + "success": true + }, + { + "mutex_wait_ns": 6200300, + "serialization_ns": 5600, + "serialized_bytes": 1075, + "statement_ns": 2549500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7200, + "serialized_bytes": 1083, + "statement_ns": 2533000, + "success": true + }, + { + "mutex_wait_ns": 5117000, + "serialization_ns": 6200, + "serialized_bytes": 1036, + "statement_ns": 2440500, + "success": true + }, + { + "mutex_wait_ns": 2453800, + "serialization_ns": 6300, + "serialized_bytes": 1299, + "statement_ns": 3726700, + "success": true + }, + { + "mutex_wait_ns": 3743300, + "serialization_ns": 5400, + "serialized_bytes": 1075, + "statement_ns": 2744700, + "success": true + }, + { + "mutex_wait_ns": 2591100, + "serialization_ns": 3600, + "serialized_bytes": 613, + "statement_ns": 2912200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3400, + "serialized_bytes": 613, + "statement_ns": 2558000, + "success": true + }, + { + "mutex_wait_ns": 5503200, + "serialization_ns": 6600, + "serialized_bytes": 1083, + "statement_ns": 2701400, + "success": true + }, + { + "mutex_wait_ns": 2715100, + "serialization_ns": 4900, + "serialized_bytes": 1040, + "statement_ns": 2501000, + "success": true + }, + { + "mutex_wait_ns": 2512700, + "serialization_ns": 6000, + "serialized_bytes": 1299, + "statement_ns": 2801800, + "success": true + }, + { + "mutex_wait_ns": 2813900, + "serialization_ns": 5500, + "serialized_bytes": 1079, + "statement_ns": 2700700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6100, + "serialized_bytes": 1087, + "statement_ns": 2730500, + "success": true + }, + { + "mutex_wait_ns": 5296100, + "serialization_ns": 2900, + "serialized_bytes": 613, + "statement_ns": 3297600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5200, + "serialized_bytes": 613, + "statement_ns": 2629000, + "success": true + }, + { + "mutex_wait_ns": 5954600, + "serialization_ns": 5900, + "serialized_bytes": 1303, + "statement_ns": 2709200, + "success": true + }, + { + "mutex_wait_ns": 2717300, + "serialization_ns": 5700, + "serialized_bytes": 1040, + "statement_ns": 2543500, + "success": true + }, + { + "mutex_wait_ns": 2390400, + "serialization_ns": 3900, + "serialized_bytes": 613, + "statement_ns": 3098500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3800, + "serialized_bytes": 613, + "statement_ns": 2881800, + "success": true + }, + { + "mutex_wait_ns": 6003200, + "serialization_ns": 6600, + "serialized_bytes": 1079, + "statement_ns": 2182800, + "success": true + }, + { + "mutex_wait_ns": 2195400, + "serialization_ns": 6700, + "serialized_bytes": 1040, + "statement_ns": 2363600, + "success": true + }, + { + "mutex_wait_ns": 2384800, + "serialization_ns": 6600, + "serialized_bytes": 1087, + "statement_ns": 2416000, + "success": true + }, + { + "mutex_wait_ns": 2432000, + "serialization_ns": 5300, + "serialized_bytes": 1079, + "statement_ns": 2599800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5000, + "serialized_bytes": 1087, + "statement_ns": 2374000, + "success": true + }, + { + "mutex_wait_ns": 5006600, + "serialization_ns": 7000, + "serialized_bytes": 1303, + "statement_ns": 2345900, + "success": true + }, + { + "mutex_wait_ns": 2358200, + "serialization_ns": 6400, + "serialized_bytes": 1303, + "statement_ns": 3016600, + "success": true + }, + { + "mutex_wait_ns": 2839900, + "serialization_ns": 3500, + "serialized_bytes": 613, + "statement_ns": 2464100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6900, + "serialized_bytes": 613, + "statement_ns": 2811100, + "success": true + }, + { + "mutex_wait_ns": 5185100, + "serialization_ns": 3700, + "serialized_bytes": 613, + "statement_ns": 2877700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4400, + "serialized_bytes": 613, + "statement_ns": 2211500, + "success": true + }, + { + "mutex_wait_ns": 5125500, + "serialization_ns": 5400, + "serialized_bytes": 1040, + "statement_ns": 2745200, + "success": true + }, + { + "mutex_wait_ns": 2758000, + "serialization_ns": 5100, + "serialized_bytes": 1040, + "statement_ns": 2933300, + "success": true + }, + { + "mutex_wait_ns": 2946800, + "serialization_ns": 6200, + "serialized_bytes": 1079, + "statement_ns": 2453300, + "success": true + }, + { + "mutex_wait_ns": 2470000, + "serialization_ns": 7000, + "serialized_bytes": 1079, + "statement_ns": 3279000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5900, + "serialized_bytes": 1087, + "statement_ns": 2469200, + "success": true + }, + { + "mutex_wait_ns": 5784800, + "serialization_ns": 6100, + "serialized_bytes": 1087, + "statement_ns": 2387500, + "success": true + }, + { + "mutex_wait_ns": 2396600, + "serialization_ns": 7100, + "serialized_bytes": 1303, + "statement_ns": 3023200, + "success": true + }, + { + "mutex_wait_ns": 3040000, + "serialization_ns": 6900, + "serialized_bytes": 1303, + "statement_ns": 2878600, + "success": true + }, + { + "mutex_wait_ns": 2724700, + "serialization_ns": 3600, + "serialized_bytes": 613, + "statement_ns": 3277700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5100, + "serialized_bytes": 613, + "statement_ns": 2735200, + "success": true + }, + { + "mutex_wait_ns": 5908500, + "serialization_ns": 3200, + "serialized_bytes": 613, + "statement_ns": 2670300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4100, + "serialized_bytes": 613, + "statement_ns": 2584400, + "success": true + }, + { + "mutex_wait_ns": 5282100, + "serialization_ns": 5300, + "serialized_bytes": 1040, + "statement_ns": 2460300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5200, + "serialized_bytes": 1079, + "statement_ns": 4949200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6700, + "serialized_bytes": 1087, + "statement_ns": 4029500, + "success": true + }, + { + "mutex_wait_ns": 11506300, + "serialization_ns": 5500, + "serialized_bytes": 1040, + "statement_ns": 2728900, + "success": true + }, + { + "mutex_wait_ns": 2740300, + "serialization_ns": 7200, + "serialized_bytes": 1303, + "statement_ns": 2649500, + "success": true + }, + { + "mutex_wait_ns": 2660100, + "serialization_ns": 7800, + "serialized_bytes": 1079, + "statement_ns": 2996800, + "success": true + }, + { + "mutex_wait_ns": 2828700, + "serialization_ns": 5400, + "serialized_bytes": 611, + "statement_ns": 3566700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5900, + "serialized_bytes": 611, + "statement_ns": 3073600, + "success": true + }, + { + "mutex_wait_ns": 6678600, + "serialization_ns": 8600, + "serialized_bytes": 1087, + "statement_ns": 3185400, + "success": true + }, + { + "mutex_wait_ns": 3203200, + "serialization_ns": 6500, + "serialized_bytes": 1036, + "statement_ns": 3021200, + "success": true + }, + { + "mutex_wait_ns": 3034800, + "serialization_ns": 8200, + "serialized_bytes": 1303, + "statement_ns": 3307000, + "success": true + }, + { + "mutex_wait_ns": 3320100, + "serialization_ns": 9500, + "serialized_bytes": 1075, + "statement_ns": 2602900, + "success": true + }, + { + "mutex_wait_ns": 2387600, + "serialization_ns": 3900, + "serialized_bytes": 613, + "statement_ns": 2788900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4400, + "serialized_bytes": 613, + "statement_ns": 2544800, + "success": true + }, + { + "mutex_wait_ns": 5367900, + "serialization_ns": 10900, + "serialized_bytes": 1083, + "statement_ns": 3861800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6800, + "serialized_bytes": 1299, + "statement_ns": 2608100, + "success": true + }, + { + "mutex_wait_ns": 6508900, + "serialization_ns": 6000, + "serialized_bytes": 1040, + "statement_ns": 2973800, + "success": true + }, + { + "mutex_wait_ns": 2830700, + "serialization_ns": 2900, + "serialized_bytes": 611, + "statement_ns": 3303600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3200, + "serialized_bytes": 611, + "statement_ns": 2727800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5300, + "serialized_bytes": 1036, + "statement_ns": 2704000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 1075, + "statement_ns": 2516900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5300, + "serialized_bytes": 1083, + "statement_ns": 2532300, + "success": true + }, + { + "mutex_wait_ns": 13886500, + "serialization_ns": 5200, + "serialized_bytes": 1079, + "statement_ns": 3480900, + "success": true + }, + { + "mutex_wait_ns": 3496800, + "serialization_ns": 7400, + "serialized_bytes": 1299, + "statement_ns": 2680700, + "success": true + }, + { + "mutex_wait_ns": 2702100, + "serialization_ns": 7700, + "serialized_bytes": 1087, + "statement_ns": 2949600, + "success": true + }, + { + "mutex_wait_ns": 2157000, + "serialization_ns": 3000, + "serialized_bytes": 613, + "statement_ns": 3163700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4400, + "serialized_bytes": 613, + "statement_ns": 3456700, + "success": true + }, + { + "mutex_wait_ns": 6646500, + "serialization_ns": 7500, + "serialized_bytes": 1303, + "statement_ns": 3278200, + "success": true + }, + { + "mutex_wait_ns": 3295600, + "serialization_ns": 5700, + "serialized_bytes": 1040, + "statement_ns": 2650100, + "success": true + }, + { + "mutex_wait_ns": 2502100, + "serialization_ns": 5800, + "serialized_bytes": 613, + "statement_ns": 2693500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7100, + "serialized_bytes": 613, + "statement_ns": 2417800, + "success": true + }, + { + "mutex_wait_ns": 5138600, + "serialization_ns": 7000, + "serialized_bytes": 1079, + "statement_ns": 2408900, + "success": true + }, + { + "mutex_wait_ns": 2424700, + "serialization_ns": 5800, + "serialized_bytes": 1040, + "statement_ns": 2741100, + "success": true + }, + { + "mutex_wait_ns": 2758500, + "serialization_ns": 6900, + "serialized_bytes": 1087, + "statement_ns": 2709700, + "success": true + }, + { + "mutex_wait_ns": 2724700, + "serialization_ns": 6700, + "serialized_bytes": 1079, + "statement_ns": 3014000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 8300, + "serialized_bytes": 1087, + "statement_ns": 2492800, + "success": true + }, + { + "mutex_wait_ns": 5544900, + "serialization_ns": 6700, + "serialized_bytes": 1303, + "statement_ns": 3033200, + "success": true + }, + { + "mutex_wait_ns": 3045000, + "serialization_ns": 7000, + "serialized_bytes": 1303, + "statement_ns": 2476200, + "success": true + }, + { + "mutex_wait_ns": 2308700, + "serialization_ns": 3800, + "serialized_bytes": 611, + "statement_ns": 2832700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4300, + "serialized_bytes": 611, + "statement_ns": 3247600, + "success": true + }, + { + "mutex_wait_ns": 5988300, + "serialization_ns": 2800, + "serialized_bytes": 613, + "statement_ns": 3135200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5300, + "serialized_bytes": 613, + "statement_ns": 2956900, + "success": true + }, + { + "mutex_wait_ns": 6123700, + "serialization_ns": 5800, + "serialized_bytes": 1036, + "statement_ns": 2368000, + "success": true + }, + { + "mutex_wait_ns": 2381000, + "serialization_ns": 7200, + "serialized_bytes": 1040, + "statement_ns": 3387800, + "success": true + }, + { + "mutex_wait_ns": 3394700, + "serialization_ns": 6400, + "serialized_bytes": 1075, + "statement_ns": 3051100, + "success": true + }, + { + "mutex_wait_ns": 3059200, + "serialization_ns": 6600, + "serialized_bytes": 1079, + "statement_ns": 3833000, + "success": true + }, + { + "mutex_wait_ns": 3852000, + "serialization_ns": 6800, + "serialized_bytes": 1083, + "statement_ns": 3121900, + "success": true + }, + { + "mutex_wait_ns": 3143400, + "serialization_ns": 8400, + "serialized_bytes": 1087, + "statement_ns": 2633400, + "success": true + }, + { + "mutex_wait_ns": 2641400, + "serialization_ns": 7100, + "serialized_bytes": 1299, + "statement_ns": 5566500, + "success": true + }, + { + "mutex_wait_ns": 5586800, + "serialization_ns": 6100, + "serialized_bytes": 1303, + "statement_ns": 2484700, + "success": true + }, + { + "mutex_wait_ns": 2307500, + "serialization_ns": 3300, + "serialized_bytes": 613, + "statement_ns": 2829300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4000, + "serialized_bytes": 613, + "statement_ns": 2415800, + "success": true + }, + { + "mutex_wait_ns": 5152400, + "serialization_ns": 3400, + "serialized_bytes": 613, + "statement_ns": 3072500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4500, + "serialized_bytes": 613, + "statement_ns": 2579000, + "success": true + }, + { + "mutex_wait_ns": 5679700, + "serialization_ns": 4900, + "serialized_bytes": 1040, + "statement_ns": 2619500, + "success": true + }, + { + "mutex_wait_ns": 2637800, + "serialization_ns": 6000, + "serialized_bytes": 1040, + "statement_ns": 2389200, + "success": true + }, + { + "mutex_wait_ns": 2399200, + "serialization_ns": 6600, + "serialized_bytes": 1079, + "statement_ns": 2708600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4600, + "serialized_bytes": 1087, + "statement_ns": 2856300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7300, + "serialized_bytes": 1303, + "statement_ns": 2994100, + "success": true + }, + { + "mutex_wait_ns": 8623400, + "serialization_ns": 4800, + "serialized_bytes": 1079, + "statement_ns": 4999300, + "success": true + }, + { + "mutex_wait_ns": 4838100, + "serialization_ns": 3300, + "serialized_bytes": 613, + "statement_ns": 3110900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4600, + "serialized_bytes": 613, + "statement_ns": 3908000, + "success": true + }, + { + "mutex_wait_ns": 7062400, + "serialization_ns": 8000, + "serialized_bytes": 1087, + "statement_ns": 3662800, + "success": true + }, + { + "mutex_wait_ns": 3677400, + "serialization_ns": 6000, + "serialized_bytes": 1040, + "statement_ns": 2643400, + "success": true + }, + { + "mutex_wait_ns": 2657000, + "serialization_ns": 7000, + "serialized_bytes": 1303, + "statement_ns": 2601400, + "success": true + }, + { + "mutex_wait_ns": 2622900, + "serialization_ns": 5800, + "serialized_bytes": 1079, + "statement_ns": 3074900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 9300, + "serialized_bytes": 1087, + "statement_ns": 2631100, + "success": true + }, + { + "mutex_wait_ns": 5314400, + "serialization_ns": 3100, + "serialized_bytes": 613, + "statement_ns": 2804800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 613, + "statement_ns": 2606500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5400, + "serialized_bytes": 1040, + "statement_ns": 2421300, + "success": true + }, + { + "mutex_wait_ns": 7884600, + "serialization_ns": 8500, + "serialized_bytes": 1303, + "statement_ns": 2793200, + "success": true + }, + { + "mutex_wait_ns": 2797300, + "serialization_ns": 7200, + "serialized_bytes": 1079, + "statement_ns": 3786600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6700, + "serialized_bytes": 1087, + "statement_ns": 2585100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1303, + "statement_ns": 3377100, + "success": true + }, + { + "mutex_wait_ns": 9615500, + "serialization_ns": 3700, + "serialized_bytes": 613, + "statement_ns": 2786500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5800, + "serialized_bytes": 613, + "statement_ns": 2840700, + "success": true + }, + { + "mutex_wait_ns": 5167400, + "serialization_ns": 3600, + "serialized_bytes": 611, + "statement_ns": 3052700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4800, + "serialized_bytes": 611, + "statement_ns": 3125200, + "success": true + }, + { + "mutex_wait_ns": 6205800, + "serialization_ns": 5500, + "serialized_bytes": 1040, + "statement_ns": 2818900, + "success": true + }, + { + "mutex_wait_ns": 2833600, + "serialization_ns": 5000, + "serialized_bytes": 1036, + "statement_ns": 3262200, + "success": true + }, + { + "mutex_wait_ns": 3268900, + "serialization_ns": 7100, + "serialized_bytes": 1079, + "statement_ns": 2917900, + "success": true + }, + { + "mutex_wait_ns": 2927400, + "serialization_ns": 6000, + "serialized_bytes": 1075, + "statement_ns": 4717500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 8800, + "serialized_bytes": 1083, + "statement_ns": 2658200, + "success": true + }, + { + "mutex_wait_ns": 7414100, + "serialization_ns": 8000, + "serialized_bytes": 1087, + "statement_ns": 2507400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6400, + "serialized_bytes": 1303, + "statement_ns": 2784700, + "success": true + }, + { + "mutex_wait_ns": 5330300, + "serialization_ns": 7700, + "serialized_bytes": 1299, + "statement_ns": 2658900, + "success": true + }, + { + "mutex_wait_ns": 2354800, + "serialization_ns": 3300, + "serialized_bytes": 611, + "statement_ns": 3165100, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 4800, + "serialized_bytes": 611, + "statement_ns": 2878300, + "success": true + }, + { + "mutex_wait_ns": 5675500, + "serialization_ns": 3300, + "serialized_bytes": 613, + "statement_ns": 3720100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4800, + "serialized_bytes": 613, + "statement_ns": 2455000, + "success": true + }, + { + "mutex_wait_ns": 6212300, + "serialization_ns": 6000, + "serialized_bytes": 1036, + "statement_ns": 3088700, + "success": true + }, + { + "mutex_wait_ns": 3111400, + "serialization_ns": 5200, + "serialized_bytes": 1040, + "statement_ns": 3208800, + "success": true + }, + { + "mutex_wait_ns": 3220000, + "serialization_ns": 6900, + "serialized_bytes": 1075, + "statement_ns": 3011800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6600, + "serialized_bytes": 1083, + "statement_ns": 2454000, + "success": true + }, + { + "mutex_wait_ns": 5493500, + "serialization_ns": 6200, + "serialized_bytes": 1079, + "statement_ns": 2564000, + "success": true + }, + { + "mutex_wait_ns": 2573000, + "serialization_ns": 6300, + "serialized_bytes": 1299, + "statement_ns": 3479100, + "success": true + }, + { + "mutex_wait_ns": 3497000, + "serialization_ns": 7400, + "serialized_bytes": 1087, + "statement_ns": 4682700, + "success": true + }, + { + "mutex_wait_ns": 3586800, + "serialization_ns": 3400, + "serialized_bytes": 611, + "statement_ns": 2645400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5000, + "serialized_bytes": 611, + "statement_ns": 2512600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1036, + "statement_ns": 2400400, + "success": true + }, + { + "mutex_wait_ns": 7609300, + "serialization_ns": 7600, + "serialized_bytes": 1303, + "statement_ns": 2601500, + "success": true + }, + { + "mutex_wait_ns": 2613000, + "serialization_ns": 5800, + "serialized_bytes": 1075, + "statement_ns": 2674300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1083, + "statement_ns": 3619900, + "success": true + }, + { + "mutex_wait_ns": 6145000, + "serialization_ns": 3400, + "serialized_bytes": 613, + "statement_ns": 3212900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 613, + "statement_ns": 2428600, + "success": true + }, + { + "mutex_wait_ns": 5676400, + "serialization_ns": 7100, + "serialized_bytes": 1299, + "statement_ns": 3371000, + "success": true + }, + { + "mutex_wait_ns": 3386700, + "serialization_ns": 6900, + "serialized_bytes": 1040, + "statement_ns": 2433700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1079, + "statement_ns": 2539100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6300, + "serialized_bytes": 1087, + "statement_ns": 2750900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7700, + "serialized_bytes": 1303, + "statement_ns": 2509300, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 584000, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=0", + "COMPILER=msvc-1944", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_W32", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "TLS", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 578147100, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 117291900, + 430037100, + 472253800, + 471998800, + 471750200, + 471646400, + 471682200, + 470687100, + 471622400, + 471378200, + 471273100, + 471295300, + 472324000, + 530307200, + 530101800, + 530126500, + 530006700, + 530036200, + 529922800, + 529813800, + 529842000, + 529559500, + 529581200, + 529465900, + 557525300, + 557572000, + 557453300, + 558257800, + 558148400, + 558186300, + 558086100, + 575865700 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 1169600, + 410768500, + 119714100, + 399600, + 321000, + 257900, + 306600 + ], + "failures": 0, + "in_window_samples": 4, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 1169600, + "end_ns": 12056700, + "in_window": true, + "scheduled_ns": null, + "start_ns": 10887100, + "success": true + }, + { + "elapsed_ns": 410768500, + "end_ns": 433208500, + "in_window": true, + "scheduled_ns": null, + "start_ns": 22440000, + "success": true + }, + { + "elapsed_ns": 119714100, + "end_ns": 563028700, + "in_window": true, + "scheduled_ns": null, + "start_ns": 443314600, + "success": true + }, + { + "elapsed_ns": 399600, + "end_ns": 573923600, + "in_window": true, + "scheduled_ns": null, + "start_ns": 573524000, + "success": true + }, + { + "elapsed_ns": 321000, + "end_ns": 584359000, + "in_window": false, + "scheduled_ns": null, + "start_ns": 584038000, + "success": true + }, + { + "elapsed_ns": 257900, + "end_ns": 594705100, + "in_window": false, + "scheduled_ns": null, + "start_ns": 594447200, + "success": true + }, + { + "elapsed_ns": 306600, + "end_ns": 605114900, + "in_window": false, + "scheduled_ns": null, + "start_ns": 604808300, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 1783600, + 409620100, + 129432400, + 5653300, + 8078100, + 810300, + 1077500, + 1576400, + 2832400 + ], + "failures": 0, + "in_window_samples": 5, + "missed_periods": 52, + "samples": [ + { + "elapsed_ns": 1783600, + "end_ns": 15188000, + "in_window": true, + "scheduled_ns": 13404400, + "start_ns": 15188000, + "success": true + }, + { + "elapsed_ns": 409620100, + "end_ns": 433024500, + "in_window": true, + "scheduled_ns": 23404400, + "start_ns": 433024500, + "success": true + }, + { + "elapsed_ns": 129432400, + "end_ns": 562836800, + "in_window": true, + "scheduled_ns": 433404400, + "start_ns": 562836800, + "success": true + }, + { + "elapsed_ns": 5653300, + "end_ns": 569057700, + "in_window": true, + "scheduled_ns": 563404400, + "start_ns": 569057700, + "success": true + }, + { + "elapsed_ns": 8078100, + "end_ns": 581482500, + "in_window": true, + "scheduled_ns": 573404400, + "start_ns": 581482500, + "success": true + }, + { + "elapsed_ns": 810300, + "end_ns": 584214700, + "in_window": false, + "scheduled_ns": 583404400, + "start_ns": 584214700, + "success": true + }, + { + "elapsed_ns": 1077500, + "end_ns": 594481900, + "in_window": false, + "scheduled_ns": 593404400, + "start_ns": 594481900, + "success": true + }, + { + "elapsed_ns": 1576400, + "end_ns": 604980800, + "in_window": false, + "scheduled_ns": 603404400, + "start_ns": 604980800, + "success": true + }, + { + "elapsed_ns": 2832400, + "end_ns": 616236800, + "in_window": false, + "scheduled_ns": 613404400, + "start_ns": 616236800, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 581584000, + "window_start_ns": 3436900 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 1, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 100, + "serialization_ns": 4400, + "serialized_bytes": 613, + "statement_ns": 3353900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5000, + "serialized_bytes": 613, + "statement_ns": 2386100, + "success": true + }, + { + "mutex_wait_ns": 3309100, + "serialization_ns": 4300, + "serialized_bytes": 613, + "statement_ns": 2565400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6200, + "serialized_bytes": 613, + "statement_ns": 2913500, + "success": true + }, + { + "mutex_wait_ns": 5517400, + "serialization_ns": 6400, + "serialized_bytes": 1040, + "statement_ns": 2361700, + "success": true + }, + { + "mutex_wait_ns": 2382100, + "serialization_ns": 6700, + "serialized_bytes": 1040, + "statement_ns": 2381700, + "success": true + }, + { + "mutex_wait_ns": 2389900, + "serialization_ns": 7900, + "serialized_bytes": 1079, + "statement_ns": 2558200, + "success": true + }, + { + "mutex_wait_ns": 2566000, + "serialization_ns": 6300, + "serialized_bytes": 1079, + "statement_ns": 2962400, + "success": true + }, + { + "mutex_wait_ns": 2982400, + "serialization_ns": 5900, + "serialized_bytes": 1087, + "statement_ns": 2276800, + "success": true + }, + { + "mutex_wait_ns": 2293500, + "serialization_ns": 6700, + "serialized_bytes": 1087, + "statement_ns": 3744800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6100, + "serialized_bytes": 1303, + "statement_ns": 2228500, + "success": true + }, + { + "mutex_wait_ns": 6005500, + "serialization_ns": 6100, + "serialized_bytes": 1303, + "statement_ns": 3071500, + "success": true + }, + { + "mutex_wait_ns": 1780000, + "serialization_ns": 3200, + "serialized_bytes": 611, + "statement_ns": 2581300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3800, + "serialized_bytes": 611, + "statement_ns": 2626500, + "success": true + }, + { + "mutex_wait_ns": 5113200, + "serialization_ns": 2900, + "serialized_bytes": 613, + "statement_ns": 3369800, + "success": true + }, + { + "mutex_wait_ns": 200, + "serialization_ns": 5100, + "serialized_bytes": 613, + "statement_ns": 4913600, + "success": true + }, + { + "mutex_wait_ns": 8313500, + "serialization_ns": 5200, + "serialized_bytes": 1036, + "statement_ns": 3223100, + "success": true + }, + { + "mutex_wait_ns": 3246000, + "serialization_ns": 4500, + "serialized_bytes": 1040, + "statement_ns": 2482300, + "success": true + }, + { + "mutex_wait_ns": 2489100, + "serialization_ns": 5800, + "serialized_bytes": 1075, + "statement_ns": 3542000, + "success": true + }, + { + "mutex_wait_ns": 3552100, + "serialization_ns": 8000, + "serialized_bytes": 1079, + "statement_ns": 2444500, + "success": true + }, + { + "mutex_wait_ns": 2461000, + "serialization_ns": 7400, + "serialized_bytes": 1083, + "statement_ns": 2588300, + "success": true + }, + { + "mutex_wait_ns": 2610900, + "serialization_ns": 6400, + "serialized_bytes": 1087, + "statement_ns": 2309600, + "success": true + }, + { + "mutex_wait_ns": 2324800, + "serialization_ns": 5300, + "serialized_bytes": 1299, + "statement_ns": 2979000, + "success": true + }, + { + "mutex_wait_ns": 3001600, + "serialization_ns": 5100, + "serialized_bytes": 1303, + "statement_ns": 2603200, + "success": true + }, + { + "mutex_wait_ns": 1331600, + "serialization_ns": 3600, + "serialized_bytes": 611, + "statement_ns": 2784200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 611, + "statement_ns": 2774500, + "success": true + }, + { + "mutex_wait_ns": 5448800, + "serialization_ns": 3300, + "serialized_bytes": 611, + "statement_ns": 2993900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4400, + "serialized_bytes": 611, + "statement_ns": 3119200, + "success": true + }, + { + "mutex_wait_ns": 6149600, + "serialization_ns": 5800, + "serialized_bytes": 1036, + "statement_ns": 4206800, + "success": true + }, + { + "mutex_wait_ns": 4227800, + "serialization_ns": 5500, + "serialized_bytes": 1036, + "statement_ns": 2960300, + "success": true + }, + { + "mutex_wait_ns": 2963400, + "serialization_ns": 6900, + "serialized_bytes": 1075, + "statement_ns": 3046300, + "success": true + }, + { + "mutex_wait_ns": 3061800, + "serialization_ns": 7300, + "serialized_bytes": 1075, + "statement_ns": 4698000, + "success": true + }, + { + "mutex_wait_ns": 4717600, + "serialization_ns": 8400, + "serialized_bytes": 1083, + "statement_ns": 2454400, + "success": true + }, + { + "mutex_wait_ns": 2468700, + "serialization_ns": 9500, + "serialized_bytes": 1083, + "statement_ns": 3502400, + "success": true + }, + { + "mutex_wait_ns": 3508900, + "serialization_ns": 7100, + "serialized_bytes": 1299, + "statement_ns": 2727800, + "success": true + }, + { + "mutex_wait_ns": 2746100, + "serialization_ns": 8300, + "serialized_bytes": 1299, + "statement_ns": 2660800, + "success": true + }, + { + "mutex_wait_ns": 2387000, + "serialization_ns": 4800, + "serialized_bytes": 613, + "statement_ns": 4144400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7800, + "serialized_bytes": 613, + "statement_ns": 2914500, + "success": true + }, + { + "mutex_wait_ns": 6960300, + "serialization_ns": 3700, + "serialized_bytes": 613, + "statement_ns": 2678800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4000, + "serialized_bytes": 613, + "statement_ns": 3034900, + "success": true + }, + { + "mutex_wait_ns": 5743300, + "serialization_ns": 7100, + "serialized_bytes": 1040, + "statement_ns": 2305900, + "success": true + }, + { + "mutex_wait_ns": 2326700, + "serialization_ns": 5300, + "serialized_bytes": 1040, + "statement_ns": 2839500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6100, + "serialized_bytes": 1079, + "statement_ns": 3275100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7100, + "serialized_bytes": 1087, + "statement_ns": 2314400, + "success": true + }, + { + "mutex_wait_ns": 8486900, + "serialization_ns": 8100, + "serialized_bytes": 1079, + "statement_ns": 2552800, + "success": true + }, + { + "mutex_wait_ns": 2571200, + "serialization_ns": 6500, + "serialized_bytes": 1303, + "statement_ns": 3174500, + "success": true + }, + { + "mutex_wait_ns": 3195900, + "serialization_ns": 8200, + "serialized_bytes": 1087, + "statement_ns": 2721600, + "success": true + }, + { + "mutex_wait_ns": 2508600, + "serialization_ns": 3500, + "serialized_bytes": 613, + "statement_ns": 3535100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5100, + "serialized_bytes": 613, + "statement_ns": 2277400, + "success": true + }, + { + "mutex_wait_ns": 5846100, + "serialization_ns": 8300, + "serialized_bytes": 1303, + "statement_ns": 2851300, + "success": true + }, + { + "mutex_wait_ns": 2870200, + "serialization_ns": 5300, + "serialized_bytes": 1040, + "statement_ns": 2561100, + "success": true + }, + { + "mutex_wait_ns": 2405500, + "serialization_ns": 3900, + "serialized_bytes": 613, + "statement_ns": 3004200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6600, + "serialized_bytes": 613, + "statement_ns": 2491300, + "success": true + }, + { + "mutex_wait_ns": 5523500, + "serialization_ns": 6500, + "serialized_bytes": 1079, + "statement_ns": 2134800, + "success": true + }, + { + "mutex_wait_ns": 2150200, + "serialization_ns": 6900, + "serialized_bytes": 1040, + "statement_ns": 2612100, + "success": true + }, + { + "mutex_wait_ns": 2630100, + "serialization_ns": 6800, + "serialized_bytes": 1087, + "statement_ns": 3360600, + "success": true + }, + { + "mutex_wait_ns": 3369400, + "serialization_ns": 6700, + "serialized_bytes": 1079, + "statement_ns": 2417500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7300, + "serialized_bytes": 1087, + "statement_ns": 3304100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6100, + "serialized_bytes": 1303, + "statement_ns": 2745200, + "success": true + }, + { + "mutex_wait_ns": 8523700, + "serialization_ns": 6000, + "serialized_bytes": 1303, + "statement_ns": 3151400, + "success": true + }, + { + "mutex_wait_ns": 2989400, + "serialization_ns": 3700, + "serialized_bytes": 613, + "statement_ns": 2905300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6000, + "serialized_bytes": 613, + "statement_ns": 2433900, + "success": true + }, + { + "mutex_wait_ns": 5239200, + "serialization_ns": 3400, + "serialized_bytes": 613, + "statement_ns": 2973100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4400, + "serialized_bytes": 613, + "statement_ns": 2745000, + "success": true + }, + { + "mutex_wait_ns": 5749100, + "serialization_ns": 5800, + "serialized_bytes": 1040, + "statement_ns": 2663800, + "success": true + }, + { + "mutex_wait_ns": 2680700, + "serialization_ns": 5100, + "serialized_bytes": 1040, + "statement_ns": 3992200, + "success": true + }, + { + "mutex_wait_ns": 4004800, + "serialization_ns": 6600, + "serialized_bytes": 1079, + "statement_ns": 2308700, + "success": true + }, + { + "mutex_wait_ns": 2327300, + "serialization_ns": 6200, + "serialized_bytes": 1079, + "statement_ns": 2680700, + "success": true + }, + { + "mutex_wait_ns": 2695400, + "serialization_ns": 8600, + "serialized_bytes": 1087, + "statement_ns": 3113300, + "success": true + }, + { + "mutex_wait_ns": 3131800, + "serialization_ns": 6800, + "serialized_bytes": 1087, + "statement_ns": 2484700, + "success": true + }, + { + "mutex_wait_ns": 2495200, + "serialization_ns": 8300, + "serialized_bytes": 1303, + "statement_ns": 2972700, + "success": true + }, + { + "mutex_wait_ns": 2983500, + "serialization_ns": 7700, + "serialized_bytes": 1303, + "statement_ns": 2792300, + "success": true + }, + { + "mutex_wait_ns": 2612400, + "serialization_ns": 4600, + "serialized_bytes": 611, + "statement_ns": 3498500, + "success": true + }, + { + "mutex_wait_ns": 3362300, + "serialization_ns": 3200, + "serialized_bytes": 613, + "statement_ns": 4264600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4900, + "serialized_bytes": 613, + "statement_ns": 4732600, + "success": true + }, + { + "mutex_wait_ns": 9032400, + "serialization_ns": 6500, + "serialized_bytes": 611, + "statement_ns": 2910300, + "success": true + }, + { + "mutex_wait_ns": 2918900, + "serialization_ns": 8000, + "serialized_bytes": 1040, + "statement_ns": 3021800, + "success": true + }, + { + "mutex_wait_ns": 3031400, + "serialization_ns": 6900, + "serialized_bytes": 1036, + "statement_ns": 2470600, + "success": true + }, + { + "mutex_wait_ns": 2476600, + "serialization_ns": 6400, + "serialized_bytes": 1079, + "statement_ns": 2604100, + "success": true + }, + { + "mutex_wait_ns": 2614000, + "serialization_ns": 7300, + "serialized_bytes": 1075, + "statement_ns": 2422100, + "success": true + }, + { + "mutex_wait_ns": 2435500, + "serialization_ns": 8000, + "serialized_bytes": 1087, + "statement_ns": 2640800, + "success": true + }, + { + "mutex_wait_ns": 2659200, + "serialization_ns": 7600, + "serialized_bytes": 1083, + "statement_ns": 3072000, + "success": true + }, + { + "mutex_wait_ns": 3083300, + "serialization_ns": 6800, + "serialized_bytes": 1303, + "statement_ns": 2690000, + "success": true + }, + { + "mutex_wait_ns": 2698800, + "serialization_ns": 7200, + "serialized_bytes": 1299, + "statement_ns": 2787500, + "success": true + }, + { + "mutex_wait_ns": 2605200, + "serialization_ns": 3000, + "serialized_bytes": 611, + "statement_ns": 5867900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4700, + "serialized_bytes": 611, + "statement_ns": 2458800, + "success": true + }, + { + "mutex_wait_ns": 8218700, + "serialization_ns": 4100, + "serialized_bytes": 613, + "statement_ns": 2558800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 613, + "statement_ns": 2391100, + "success": true + }, + { + "mutex_wait_ns": 4980900, + "serialization_ns": 5800, + "serialized_bytes": 1036, + "statement_ns": 2467800, + "success": true + }, + { + "mutex_wait_ns": 2477800, + "serialization_ns": 8400, + "serialized_bytes": 1040, + "statement_ns": 3054800, + "success": true + }, + { + "mutex_wait_ns": 3063500, + "serialization_ns": 6700, + "serialized_bytes": 1075, + "statement_ns": 2586000, + "success": true + }, + { + "mutex_wait_ns": 2597900, + "serialization_ns": 6400, + "serialized_bytes": 1079, + "statement_ns": 2634500, + "success": true + }, + { + "mutex_wait_ns": 2653900, + "serialization_ns": 5300, + "serialized_bytes": 1083, + "statement_ns": 3000400, + "success": true + }, + { + "mutex_wait_ns": 3018400, + "serialization_ns": 7100, + "serialized_bytes": 1087, + "statement_ns": 2446800, + "success": true + }, + { + "mutex_wait_ns": 2461100, + "serialization_ns": 6400, + "serialized_bytes": 1299, + "statement_ns": 2891600, + "success": true + }, + { + "mutex_wait_ns": 2911300, + "serialization_ns": 5300, + "serialized_bytes": 1303, + "statement_ns": 2353700, + "success": true + }, + { + "mutex_wait_ns": 2152100, + "serialization_ns": 4400, + "serialized_bytes": 611, + "statement_ns": 2563700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5300, + "serialized_bytes": 611, + "statement_ns": 2815800, + "success": true + }, + { + "mutex_wait_ns": 5269400, + "serialization_ns": 4900, + "serialized_bytes": 613, + "statement_ns": 2339200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6000, + "serialized_bytes": 613, + "statement_ns": 2375800, + "success": true + }, + { + "mutex_wait_ns": 4747600, + "serialization_ns": 5800, + "serialized_bytes": 1036, + "statement_ns": 2508100, + "success": true + }, + { + "mutex_wait_ns": 2520700, + "serialization_ns": 6500, + "serialized_bytes": 1040, + "statement_ns": 3393800, + "success": true + }, + { + "mutex_wait_ns": 3404200, + "serialization_ns": 4700, + "serialized_bytes": 1075, + "statement_ns": 2735700, + "success": true + }, + { + "mutex_wait_ns": 2746800, + "serialization_ns": 8300, + "serialized_bytes": 1079, + "statement_ns": 2615500, + "success": true + }, + { + "mutex_wait_ns": 2628400, + "serialization_ns": 8800, + "serialized_bytes": 1083, + "statement_ns": 2320400, + "success": true + }, + { + "mutex_wait_ns": 2335400, + "serialization_ns": 7900, + "serialized_bytes": 1087, + "statement_ns": 2566800, + "success": true + }, + { + "mutex_wait_ns": 2580400, + "serialization_ns": 5600, + "serialized_bytes": 1299, + "statement_ns": 2808700, + "success": true + }, + { + "mutex_wait_ns": 2824900, + "serialization_ns": 6300, + "serialized_bytes": 1303, + "statement_ns": 2390400, + "success": true + }, + { + "mutex_wait_ns": 2191800, + "serialization_ns": 3700, + "serialized_bytes": 611, + "statement_ns": 2715000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4400, + "serialized_bytes": 611, + "statement_ns": 3113600, + "success": true + }, + { + "mutex_wait_ns": 5722900, + "serialization_ns": 4700, + "serialized_bytes": 613, + "statement_ns": 5553500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7600, + "serialized_bytes": 613, + "statement_ns": 2647100, + "success": true + }, + { + "mutex_wait_ns": 8241000, + "serialization_ns": 5400, + "serialized_bytes": 1036, + "statement_ns": 2771300, + "success": true + }, + { + "mutex_wait_ns": 2784100, + "serialization_ns": 6800, + "serialized_bytes": 1040, + "statement_ns": 3487700, + "success": true + }, + { + "mutex_wait_ns": 3496700, + "serialization_ns": 5900, + "serialized_bytes": 1075, + "statement_ns": 2419400, + "success": true + }, + { + "mutex_wait_ns": 2430000, + "serialization_ns": 6800, + "serialized_bytes": 1079, + "statement_ns": 2462400, + "success": true + }, + { + "mutex_wait_ns": 2480700, + "serialization_ns": 5300, + "serialized_bytes": 1083, + "statement_ns": 2448000, + "success": true + }, + { + "mutex_wait_ns": 2467200, + "serialization_ns": 6900, + "serialized_bytes": 1087, + "statement_ns": 2331400, + "success": true + }, + { + "mutex_wait_ns": 2344500, + "serialization_ns": 5500, + "serialized_bytes": 1299, + "statement_ns": 2950400, + "success": true + }, + { + "mutex_wait_ns": 2962400, + "serialization_ns": 6800, + "serialized_bytes": 1303, + "statement_ns": 2332600, + "success": true + }, + { + "mutex_wait_ns": 2139200, + "serialization_ns": 4100, + "serialized_bytes": 613, + "statement_ns": 2897600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5000, + "serialized_bytes": 613, + "statement_ns": 2844600, + "success": true + }, + { + "mutex_wait_ns": 5626600, + "serialization_ns": 4400, + "serialized_bytes": 613, + "statement_ns": 2664300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 613, + "statement_ns": 3497900, + "success": true + }, + { + "mutex_wait_ns": 6196500, + "serialization_ns": 5900, + "serialized_bytes": 1040, + "statement_ns": 2532200, + "success": true + }, + { + "mutex_wait_ns": 2542900, + "serialization_ns": 7300, + "serialized_bytes": 1040, + "statement_ns": 2717200, + "success": true + }, + { + "mutex_wait_ns": 2725500, + "serialization_ns": 6400, + "serialized_bytes": 1079, + "statement_ns": 2558500, + "success": true + }, + { + "mutex_wait_ns": 2569500, + "serialization_ns": 6100, + "serialized_bytes": 1079, + "statement_ns": 2781700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5900, + "serialized_bytes": 1087, + "statement_ns": 2741300, + "success": true + }, + { + "mutex_wait_ns": 5562300, + "serialization_ns": 5300, + "serialized_bytes": 1087, + "statement_ns": 2863500, + "success": true + }, + { + "mutex_wait_ns": 2869100, + "serialization_ns": 7600, + "serialized_bytes": 1303, + "statement_ns": 2694700, + "success": true + }, + { + "mutex_wait_ns": 2703300, + "serialization_ns": 6600, + "serialized_bytes": 1303, + "statement_ns": 5146300, + "success": true + }, + { + "mutex_wait_ns": 4882900, + "serialization_ns": 5800, + "serialized_bytes": 613, + "statement_ns": 2924900, + "success": true + }, + { + "mutex_wait_ns": 2793000, + "serialization_ns": 3700, + "serialized_bytes": 613, + "statement_ns": 2936400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 613, + "statement_ns": 2448500, + "success": true + }, + { + "mutex_wait_ns": 5420200, + "serialization_ns": 6500, + "serialized_bytes": 613, + "statement_ns": 2457200, + "success": true + }, + { + "mutex_wait_ns": 2467900, + "serialization_ns": 6100, + "serialized_bytes": 1040, + "statement_ns": 2800400, + "success": true + }, + { + "mutex_wait_ns": 2809800, + "serialization_ns": 7000, + "serialized_bytes": 1040, + "statement_ns": 2320800, + "success": true + }, + { + "mutex_wait_ns": 2326400, + "serialization_ns": 6300, + "serialized_bytes": 1079, + "statement_ns": 2430500, + "success": true + }, + { + "mutex_wait_ns": 2437900, + "serialization_ns": 7700, + "serialized_bytes": 1079, + "statement_ns": 3945000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7000, + "serialized_bytes": 1087, + "statement_ns": 2824200, + "success": true + }, + { + "mutex_wait_ns": 6805000, + "serialization_ns": 4400, + "serialized_bytes": 1087, + "statement_ns": 2567700, + "success": true + }, + { + "mutex_wait_ns": 2573700, + "serialization_ns": 8200, + "serialized_bytes": 1303, + "statement_ns": 2899300, + "success": true + }, + { + "mutex_wait_ns": 2912000, + "serialization_ns": 5600, + "serialized_bytes": 1303, + "statement_ns": 2923600, + "success": true + }, + { + "mutex_wait_ns": 2442600, + "serialization_ns": 4500, + "serialized_bytes": 613, + "statement_ns": 3669600, + "success": true + }, + { + "mutex_wait_ns": 3470000, + "serialization_ns": 3100, + "serialized_bytes": 613, + "statement_ns": 6622000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5500, + "serialized_bytes": 613, + "statement_ns": 2757900, + "success": true + }, + { + "mutex_wait_ns": 9415700, + "serialization_ns": 7400, + "serialized_bytes": 613, + "statement_ns": 2329700, + "success": true + }, + { + "mutex_wait_ns": 2340400, + "serialization_ns": 6000, + "serialized_bytes": 1040, + "statement_ns": 2471100, + "success": true + }, + { + "mutex_wait_ns": 2483200, + "serialization_ns": 7600, + "serialized_bytes": 1040, + "statement_ns": 2804400, + "success": true + }, + { + "mutex_wait_ns": 2813500, + "serialization_ns": 6600, + "serialized_bytes": 1079, + "statement_ns": 3625600, + "success": true + }, + { + "mutex_wait_ns": 3632700, + "serialization_ns": 6800, + "serialized_bytes": 1079, + "statement_ns": 2962900, + "success": true + }, + { + "mutex_wait_ns": 2981000, + "serialization_ns": 6700, + "serialized_bytes": 1087, + "statement_ns": 2656400, + "success": true + }, + { + "mutex_wait_ns": 2669100, + "serialization_ns": 8400, + "serialized_bytes": 1087, + "statement_ns": 2642500, + "success": true + }, + { + "mutex_wait_ns": 2653200, + "serialization_ns": 6400, + "serialized_bytes": 1303, + "statement_ns": 3462900, + "success": true + }, + { + "mutex_wait_ns": 3473400, + "serialization_ns": 8600, + "serialized_bytes": 1303, + "statement_ns": 4201800, + "success": true + }, + { + "mutex_wait_ns": 4026000, + "serialization_ns": 3400, + "serialized_bytes": 611, + "statement_ns": 2752500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4200, + "serialized_bytes": 611, + "statement_ns": 2831300, + "success": true + }, + { + "mutex_wait_ns": 4998300, + "serialization_ns": 4200, + "serialized_bytes": 611, + "statement_ns": 2815200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5600, + "serialized_bytes": 611, + "statement_ns": 2890000, + "success": true + }, + { + "mutex_wait_ns": 5738700, + "serialization_ns": 5200, + "serialized_bytes": 1036, + "statement_ns": 2627300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 8200, + "serialized_bytes": 1075, + "statement_ns": 3309200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6300, + "serialized_bytes": 1083, + "statement_ns": 4156000, + "success": true + }, + { + "mutex_wait_ns": 10182800, + "serialization_ns": 7400, + "serialized_bytes": 1036, + "statement_ns": 2740400, + "success": true + }, + { + "mutex_wait_ns": 2755900, + "serialization_ns": 6000, + "serialized_bytes": 1299, + "statement_ns": 3943700, + "success": true + }, + { + "mutex_wait_ns": 3952100, + "serialization_ns": 7400, + "serialized_bytes": 1075, + "statement_ns": 3689800, + "success": true + }, + { + "mutex_wait_ns": 3538900, + "serialization_ns": 3000, + "serialized_bytes": 613, + "statement_ns": 2506200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4200, + "serialized_bytes": 613, + "statement_ns": 2529500, + "success": true + }, + { + "mutex_wait_ns": 5067200, + "serialization_ns": 8100, + "serialized_bytes": 1083, + "statement_ns": 2411500, + "success": true + }, + { + "mutex_wait_ns": 2427000, + "serialization_ns": 6000, + "serialized_bytes": 1040, + "statement_ns": 2382200, + "success": true + }, + { + "mutex_wait_ns": 2385100, + "serialization_ns": 8300, + "serialized_bytes": 1299, + "statement_ns": 2680500, + "success": true + }, + { + "mutex_wait_ns": 2691700, + "serialization_ns": 6500, + "serialized_bytes": 1079, + "statement_ns": 2694300, + "success": true + }, + { + "mutex_wait_ns": 2454000, + "serialization_ns": 4800, + "serialized_bytes": 613, + "statement_ns": 2493400, + "success": true + }, + { + "mutex_wait_ns": 2513000, + "serialization_ns": 6400, + "serialized_bytes": 1087, + "statement_ns": 2592600, + "success": true + }, + { + "mutex_wait_ns": 2610900, + "serialization_ns": 5800, + "serialized_bytes": 613, + "statement_ns": 2354400, + "success": true + }, + { + "mutex_wait_ns": 2362800, + "serialization_ns": 7000, + "serialized_bytes": 1303, + "statement_ns": 2670700, + "success": true + }, + { + "mutex_wait_ns": 2686700, + "serialization_ns": 6000, + "serialized_bytes": 1040, + "statement_ns": 2478200, + "success": true + }, + { + "mutex_wait_ns": 1935700, + "serialization_ns": 4100, + "serialized_bytes": 611, + "statement_ns": 2605100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3900, + "serialized_bytes": 611, + "statement_ns": 2482500, + "success": true + }, + { + "mutex_wait_ns": 5110500, + "serialization_ns": 7200, + "serialized_bytes": 1079, + "statement_ns": 2385500, + "success": true + }, + { + "mutex_wait_ns": 2401500, + "serialization_ns": 5400, + "serialized_bytes": 1036, + "statement_ns": 2247100, + "success": true + }, + { + "mutex_wait_ns": 2260700, + "serialization_ns": 8100, + "serialized_bytes": 1087, + "statement_ns": 2495300, + "success": true + }, + { + "mutex_wait_ns": 2504700, + "serialization_ns": 6300, + "serialized_bytes": 1075, + "statement_ns": 2612900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4900, + "serialized_bytes": 1083, + "statement_ns": 2735800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6200, + "serialized_bytes": 1299, + "statement_ns": 3060800, + "success": true + }, + { + "mutex_wait_ns": 8467100, + "serialization_ns": 8000, + "serialized_bytes": 1303, + "statement_ns": 5574500, + "success": true + }, + { + "mutex_wait_ns": 5395900, + "serialization_ns": 3800, + "serialized_bytes": 613, + "statement_ns": 4122900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5600, + "serialized_bytes": 613, + "statement_ns": 2811000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7200, + "serialized_bytes": 1040, + "statement_ns": 2884500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7000, + "serialized_bytes": 1079, + "statement_ns": 2436000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5900, + "serialized_bytes": 1087, + "statement_ns": 3608300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1303, + "statement_ns": 2919400, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 829400, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=0", + "COMPILER=msvc-1944", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_W32", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "TLS", + "wall_budget_exceeded": false + }, + { + "batch_elapsed_ns": 570081800, + "batch_timeout_s": 60, + "client_configuration": { + "barrier": 32, + "http": "1.1 only", + "pool": "shared client clones", + "tls": "fresh archive and client per batch; interception CA trusted; no external upstream" + }, + "client_elapsed_ns": [ + 118891200, + 118749400, + 129602200, + 129652200, + 147057000, + 146954500, + 288025100, + 302001000, + 302049400, + 301950200, + 301843900, + 301908400, + 301386200, + 524635200, + 552165700, + 554818100, + 554925400, + 554736400, + 554633200, + 554711800, + 555220700, + 553982300, + 554008600, + 553896300, + 553924300, + 553794700, + 553675800, + 553555800, + 553347300, + 554816100, + 552892900, + 569200900 + ], + "client_timeout_s": 30, + "clients": 32, + "control_baseline_restored": true, + "cooperative_batch_timeout": false, + "evidence_corruption_control_detected": true, + "evidence_loss_control_detected": true, + "evidence_valid": true, + "joined": 32, + "persisted_rows": 32, + "probes": { + "cap_per_probe": 8192, + "network": { + "dropped": 0, + "elapsed_ns": [ + 376600, + 78632300, + 48533000, + 397950100, + 426400, + 295000, + 343600, + 354700 + ], + "failures": 0, + "in_window_samples": 5, + "missed_periods": 0, + "samples": [ + { + "elapsed_ns": 376600, + "end_ns": 11413000, + "in_window": true, + "scheduled_ns": null, + "start_ns": 11036400, + "success": true + }, + { + "elapsed_ns": 78632300, + "end_ns": 100153200, + "in_window": true, + "scheduled_ns": null, + "start_ns": 21520900, + "success": true + }, + { + "elapsed_ns": 48533000, + "end_ns": 158794300, + "in_window": true, + "scheduled_ns": null, + "start_ns": 110261300, + "success": true + }, + { + "elapsed_ns": 397950100, + "end_ns": 566892600, + "in_window": true, + "scheduled_ns": null, + "start_ns": 168942500, + "success": true + }, + { + "elapsed_ns": 426400, + "end_ns": 577451200, + "in_window": true, + "scheduled_ns": null, + "start_ns": 577024800, + "success": true + }, + { + "elapsed_ns": 295000, + "end_ns": 587928600, + "in_window": false, + "scheduled_ns": null, + "start_ns": 587633600, + "success": true + }, + { + "elapsed_ns": 343600, + "end_ns": 598405900, + "in_window": false, + "scheduled_ns": null, + "start_ns": 598062300, + "success": true + }, + { + "elapsed_ns": 354700, + "end_ns": 608881300, + "in_window": false, + "scheduled_ns": null, + "start_ns": 608526600, + "success": true + } + ], + "window_status": "PASS" + }, + "period_ms": 10, + "timer": { + "dropped": 0, + "elapsed_ns": [ + 30173000, + 67016500, + 152750600, + 275783400, + 5969600, + 6340400, + 3721300, + 7421200, + 15758200 + ], + "failures": 0, + "in_window_samples": 6, + "missed_periods": 52, + "samples": [ + { + "elapsed_ns": 30173000, + "end_ns": 51486000, + "in_window": true, + "scheduled_ns": 21313000, + "start_ns": 51486000, + "success": true + }, + { + "elapsed_ns": 67016500, + "end_ns": 128329500, + "in_window": true, + "scheduled_ns": 61313000, + "start_ns": 128329500, + "success": true + }, + { + "elapsed_ns": 152750600, + "end_ns": 284063600, + "in_window": true, + "scheduled_ns": 131313000, + "start_ns": 284063600, + "success": true + }, + { + "elapsed_ns": 275783400, + "end_ns": 567096400, + "in_window": true, + "scheduled_ns": 291313000, + "start_ns": 567096400, + "success": true + }, + { + "elapsed_ns": 5969600, + "end_ns": 577282600, + "in_window": true, + "scheduled_ns": 571313000, + "start_ns": 577282600, + "success": true + }, + { + "elapsed_ns": 6340400, + "end_ns": 587653400, + "in_window": true, + "scheduled_ns": 581313000, + "start_ns": 587653400, + "success": true + }, + { + "elapsed_ns": 3721300, + "end_ns": 595034300, + "in_window": false, + "scheduled_ns": 591313000, + "start_ns": 595034300, + "success": true + }, + { + "elapsed_ns": 7421200, + "end_ns": 608734200, + "in_window": false, + "scheduled_ns": 601313000, + "start_ns": 608734200, + "success": true + }, + { + "elapsed_ns": 15758200, + "end_ns": 627071200, + "in_window": false, + "scheduled_ns": 611313000, + "start_ns": 627071200, + "success": true + } + ], + "window_status": "PASS" + }, + "window_end_ns": 581414300, + "window_start_ns": 11332500 + }, + "reopened_evidence_valid": true, + "revision_delta": 192, + "sample": 2, + "save_cap": 256, + "saves": { + "dropped": 0, + "samples": [ + { + "mutex_wait_ns": 0, + "serialization_ns": 4200, + "serialized_bytes": 613, + "statement_ns": 3252900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 613, + "statement_ns": 2605400, + "success": true + }, + { + "mutex_wait_ns": 1481300, + "serialization_ns": 3600, + "serialized_bytes": 613, + "statement_ns": 3047800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5700, + "serialized_bytes": 613, + "statement_ns": 2622000, + "success": true + }, + { + "mutex_wait_ns": 5700100, + "serialization_ns": 6700, + "serialized_bytes": 1040, + "statement_ns": 4064000, + "success": true + }, + { + "mutex_wait_ns": 4062300, + "serialization_ns": 6200, + "serialized_bytes": 1040, + "statement_ns": 2513500, + "success": true + }, + { + "mutex_wait_ns": 2527100, + "serialization_ns": 5400, + "serialized_bytes": 1079, + "statement_ns": 2792100, + "success": true + }, + { + "mutex_wait_ns": 2808800, + "serialization_ns": 5200, + "serialized_bytes": 1079, + "statement_ns": 2548500, + "success": true + }, + { + "mutex_wait_ns": 2562700, + "serialization_ns": 8200, + "serialized_bytes": 1087, + "statement_ns": 2387500, + "success": true + }, + { + "mutex_wait_ns": 2404200, + "serialization_ns": 6400, + "serialized_bytes": 1087, + "statement_ns": 2503100, + "success": true + }, + { + "mutex_wait_ns": 2514300, + "serialization_ns": 6300, + "serialized_bytes": 1303, + "statement_ns": 2416500, + "success": true + }, + { + "mutex_wait_ns": 2427800, + "serialization_ns": 6700, + "serialized_bytes": 1303, + "statement_ns": 2518600, + "success": true + }, + { + "mutex_wait_ns": 236100, + "serialization_ns": 3200, + "serialized_bytes": 613, + "statement_ns": 2737000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4100, + "serialized_bytes": 613, + "statement_ns": 2913400, + "success": true + }, + { + "mutex_wait_ns": 5572800, + "serialization_ns": 2700, + "serialized_bytes": 613, + "statement_ns": 2862700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3900, + "serialized_bytes": 613, + "statement_ns": 2339100, + "success": true + }, + { + "mutex_wait_ns": 5227900, + "serialization_ns": 5000, + "serialized_bytes": 1040, + "statement_ns": 3554800, + "success": true + }, + { + "mutex_wait_ns": 3565200, + "serialization_ns": 5100, + "serialized_bytes": 1040, + "statement_ns": 2526400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4500, + "serialized_bytes": 1079, + "statement_ns": 2453500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5000, + "serialized_bytes": 1087, + "statement_ns": 4989400, + "success": true + }, + { + "mutex_wait_ns": 10010200, + "serialization_ns": 5700, + "serialized_bytes": 1079, + "statement_ns": 3068700, + "success": true + }, + { + "mutex_wait_ns": 3078900, + "serialization_ns": 6700, + "serialized_bytes": 1303, + "statement_ns": 4380800, + "success": true + }, + { + "mutex_wait_ns": 4403900, + "serialization_ns": 5400, + "serialized_bytes": 1087, + "statement_ns": 2393000, + "success": true + }, + { + "mutex_wait_ns": 2244900, + "serialization_ns": 3000, + "serialized_bytes": 613, + "statement_ns": 2978800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4200, + "serialized_bytes": 613, + "statement_ns": 6107600, + "success": true + }, + { + "mutex_wait_ns": 9114300, + "serialization_ns": 5800, + "serialized_bytes": 1303, + "statement_ns": 2581300, + "success": true + }, + { + "mutex_wait_ns": 2593600, + "serialization_ns": 4900, + "serialized_bytes": 1040, + "statement_ns": 2596000, + "success": true + }, + { + "mutex_wait_ns": 2349400, + "serialization_ns": 2800, + "serialized_bytes": 613, + "statement_ns": 2623900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4200, + "serialized_bytes": 613, + "statement_ns": 4947800, + "success": true + }, + { + "mutex_wait_ns": 7599800, + "serialization_ns": 5900, + "serialized_bytes": 1079, + "statement_ns": 2708600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6400, + "serialized_bytes": 1087, + "statement_ns": 2612700, + "success": true + }, + { + "mutex_wait_ns": 5356500, + "serialization_ns": 5900, + "serialized_bytes": 1040, + "statement_ns": 4477000, + "success": true + }, + { + "mutex_wait_ns": 4490200, + "serialization_ns": 5600, + "serialized_bytes": 1303, + "statement_ns": 5855600, + "success": true + }, + { + "mutex_wait_ns": 5870300, + "serialization_ns": 5400, + "serialized_bytes": 1079, + "statement_ns": 2812200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7300, + "serialized_bytes": 1087, + "statement_ns": 2998000, + "success": true + }, + { + "mutex_wait_ns": 889600, + "serialization_ns": 3500, + "serialized_bytes": 611, + "statement_ns": 2776000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4500, + "serialized_bytes": 611, + "statement_ns": 2608700, + "success": true + }, + { + "mutex_wait_ns": 5416500, + "serialization_ns": 6900, + "serialized_bytes": 1303, + "statement_ns": 2461600, + "success": true + }, + { + "mutex_wait_ns": 2471900, + "serialization_ns": 5600, + "serialized_bytes": 1036, + "statement_ns": 2336000, + "success": true + }, + { + "mutex_wait_ns": 720200, + "serialization_ns": 3500, + "serialized_bytes": 613, + "statement_ns": 3463400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4500, + "serialized_bytes": 613, + "statement_ns": 2471800, + "success": true + }, + { + "mutex_wait_ns": 5966100, + "serialization_ns": 5800, + "serialized_bytes": 1075, + "statement_ns": 2783500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6100, + "serialized_bytes": 1083, + "statement_ns": 2477500, + "success": true + }, + { + "mutex_wait_ns": 5293200, + "serialization_ns": 4700, + "serialized_bytes": 1040, + "statement_ns": 2578200, + "success": true + }, + { + "mutex_wait_ns": 2589000, + "serialization_ns": 5900, + "serialized_bytes": 1299, + "statement_ns": 2724700, + "success": true + }, + { + "mutex_wait_ns": 2742200, + "serialization_ns": 5400, + "serialized_bytes": 1079, + "statement_ns": 2706000, + "success": true + }, + { + "mutex_wait_ns": 2329900, + "serialization_ns": 3100, + "serialized_bytes": 613, + "statement_ns": 2884500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3500, + "serialized_bytes": 613, + "statement_ns": 3138700, + "success": true + }, + { + "mutex_wait_ns": 6053000, + "serialization_ns": 6400, + "serialized_bytes": 1087, + "statement_ns": 2675700, + "success": true + }, + { + "mutex_wait_ns": 2690800, + "serialization_ns": 5300, + "serialized_bytes": 1040, + "statement_ns": 2906300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4400, + "serialized_bytes": 1079, + "statement_ns": 2397700, + "success": true + }, + { + "mutex_wait_ns": 5339700, + "serialization_ns": 7400, + "serialized_bytes": 1303, + "statement_ns": 4531700, + "success": true + }, + { + "mutex_wait_ns": 4550100, + "serialization_ns": 5900, + "serialized_bytes": 1087, + "statement_ns": 6839800, + "success": true + }, + { + "mutex_wait_ns": 5917000, + "serialization_ns": 3000, + "serialized_bytes": 613, + "statement_ns": 3142500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4800, + "serialized_bytes": 613, + "statement_ns": 2285700, + "success": true + }, + { + "mutex_wait_ns": 5452900, + "serialization_ns": 6900, + "serialized_bytes": 1303, + "statement_ns": 4681600, + "success": true + }, + { + "mutex_wait_ns": 4696100, + "serialization_ns": 5200, + "serialized_bytes": 1040, + "statement_ns": 3532300, + "success": true + }, + { + "mutex_wait_ns": 3387100, + "serialization_ns": 2900, + "serialized_bytes": 613, + "statement_ns": 2771100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3700, + "serialized_bytes": 613, + "statement_ns": 2948700, + "success": true + }, + { + "mutex_wait_ns": 5744300, + "serialization_ns": 6200, + "serialized_bytes": 1079, + "statement_ns": 2613500, + "success": true + }, + { + "mutex_wait_ns": 2626000, + "serialization_ns": 5200, + "serialized_bytes": 1040, + "statement_ns": 2302700, + "success": true + }, + { + "mutex_wait_ns": 2325400, + "serialization_ns": 5500, + "serialized_bytes": 1087, + "statement_ns": 2361600, + "success": true + }, + { + "mutex_wait_ns": 2378200, + "serialization_ns": 4800, + "serialized_bytes": 1079, + "statement_ns": 2436200, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6000, + "serialized_bytes": 1087, + "statement_ns": 2346100, + "success": true + }, + { + "mutex_wait_ns": 4817400, + "serialization_ns": 4500, + "serialized_bytes": 1303, + "statement_ns": 2423400, + "success": true + }, + { + "mutex_wait_ns": 2435000, + "serialization_ns": 5600, + "serialized_bytes": 1303, + "statement_ns": 2517300, + "success": true + }, + { + "mutex_wait_ns": 2362300, + "serialization_ns": 2800, + "serialized_bytes": 613, + "statement_ns": 2903400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4000, + "serialized_bytes": 613, + "statement_ns": 2476000, + "success": true + }, + { + "mutex_wait_ns": 5290700, + "serialization_ns": 3100, + "serialized_bytes": 611, + "statement_ns": 2866900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4100, + "serialized_bytes": 611, + "statement_ns": 2744900, + "success": true + }, + { + "mutex_wait_ns": 5647000, + "serialization_ns": 4600, + "serialized_bytes": 1040, + "statement_ns": 2268600, + "success": true + }, + { + "mutex_wait_ns": 2281500, + "serialization_ns": 5300, + "serialized_bytes": 1036, + "statement_ns": 2652400, + "success": true + }, + { + "mutex_wait_ns": 2665100, + "serialization_ns": 6000, + "serialized_bytes": 1079, + "statement_ns": 2920200, + "success": true + }, + { + "mutex_wait_ns": 2936500, + "serialization_ns": 5200, + "serialized_bytes": 1075, + "statement_ns": 2854000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4900, + "serialized_bytes": 1083, + "statement_ns": 2846100, + "success": true + }, + { + "mutex_wait_ns": 5737300, + "serialization_ns": 5700, + "serialized_bytes": 1087, + "statement_ns": 4009100, + "success": true + }, + { + "mutex_wait_ns": 4020600, + "serialization_ns": 6300, + "serialized_bytes": 1299, + "statement_ns": 2668300, + "success": true + }, + { + "mutex_wait_ns": 2685200, + "serialization_ns": 6800, + "serialized_bytes": 1303, + "statement_ns": 2781600, + "success": true + }, + { + "mutex_wait_ns": 2247200, + "serialization_ns": 3100, + "serialized_bytes": 611, + "statement_ns": 3276000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4600, + "serialized_bytes": 611, + "statement_ns": 2416700, + "success": true + }, + { + "mutex_wait_ns": 5594800, + "serialization_ns": 3100, + "serialized_bytes": 613, + "statement_ns": 2497500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5500, + "serialized_bytes": 613, + "statement_ns": 2267000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5400, + "serialized_bytes": 1040, + "statement_ns": 2463000, + "success": true + }, + { + "mutex_wait_ns": 7295400, + "serialization_ns": 7100, + "serialized_bytes": 1036, + "statement_ns": 3126500, + "success": true + }, + { + "mutex_wait_ns": 3144000, + "serialization_ns": 5600, + "serialized_bytes": 1079, + "statement_ns": 4178400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6500, + "serialized_bytes": 1087, + "statement_ns": 3123900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6000, + "serialized_bytes": 1303, + "statement_ns": 2629500, + "success": true + }, + { + "mutex_wait_ns": 9990300, + "serialization_ns": 7500, + "serialized_bytes": 1075, + "statement_ns": 2758200, + "success": true + }, + { + "mutex_wait_ns": 2428200, + "serialization_ns": 3200, + "serialized_bytes": 613, + "statement_ns": 3100900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4400, + "serialized_bytes": 613, + "statement_ns": 2579000, + "success": true + }, + { + "mutex_wait_ns": 5713900, + "serialization_ns": 8000, + "serialized_bytes": 1083, + "statement_ns": 3080900, + "success": true + }, + { + "mutex_wait_ns": 3092200, + "serialization_ns": 6800, + "serialized_bytes": 1040, + "statement_ns": 2349900, + "success": true + }, + { + "mutex_wait_ns": 2358600, + "serialization_ns": 8700, + "serialized_bytes": 1299, + "statement_ns": 2720700, + "success": true + }, + { + "mutex_wait_ns": 2750100, + "serialization_ns": 5500, + "serialized_bytes": 1079, + "statement_ns": 3001100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6400, + "serialized_bytes": 1087, + "statement_ns": 2512400, + "success": true + }, + { + "mutex_wait_ns": 5123800, + "serialization_ns": 5400, + "serialized_bytes": 613, + "statement_ns": 3230700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6500, + "serialized_bytes": 613, + "statement_ns": 2655600, + "success": true + }, + { + "mutex_wait_ns": 5922100, + "serialization_ns": 6100, + "serialized_bytes": 1303, + "statement_ns": 2690800, + "success": true + }, + { + "mutex_wait_ns": 2700500, + "serialization_ns": 9200, + "serialized_bytes": 1040, + "statement_ns": 2266300, + "success": true + }, + { + "mutex_wait_ns": 1870000, + "serialization_ns": 3600, + "serialized_bytes": 613, + "statement_ns": 3018900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4100, + "serialized_bytes": 613, + "statement_ns": 2968000, + "success": true + }, + { + "mutex_wait_ns": 6005700, + "serialization_ns": 12400, + "serialized_bytes": 1079, + "statement_ns": 2596200, + "success": true + }, + { + "mutex_wait_ns": 2609800, + "serialization_ns": 5700, + "serialized_bytes": 1040, + "statement_ns": 2710000, + "success": true + }, + { + "mutex_wait_ns": 2724800, + "serialization_ns": 8100, + "serialized_bytes": 1087, + "statement_ns": 2643300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6000, + "serialized_bytes": 1303, + "statement_ns": 3104000, + "success": true + }, + { + "mutex_wait_ns": 5787100, + "serialization_ns": 5300, + "serialized_bytes": 1079, + "statement_ns": 2369100, + "success": true + }, + { + "mutex_wait_ns": 2223200, + "serialization_ns": 3600, + "serialized_bytes": 613, + "statement_ns": 2530800, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3200, + "serialized_bytes": 613, + "statement_ns": 2194500, + "success": true + }, + { + "mutex_wait_ns": 4756200, + "serialization_ns": 5800, + "serialized_bytes": 1087, + "statement_ns": 2644800, + "success": true + }, + { + "mutex_wait_ns": 2658200, + "serialization_ns": 4700, + "serialized_bytes": 1040, + "statement_ns": 2386400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5500, + "serialized_bytes": 1079, + "statement_ns": 2284900, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5500, + "serialized_bytes": 1087, + "statement_ns": 2429300, + "success": true + }, + { + "mutex_wait_ns": 7155100, + "serialization_ns": 5500, + "serialized_bytes": 1303, + "statement_ns": 2274000, + "success": true + }, + { + "mutex_wait_ns": 2289200, + "serialization_ns": 5100, + "serialized_bytes": 1303, + "statement_ns": 2806100, + "success": true + }, + { + "mutex_wait_ns": 2668300, + "serialization_ns": 2900, + "serialized_bytes": 613, + "statement_ns": 3123600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4700, + "serialized_bytes": 613, + "statement_ns": 2710200, + "success": true + }, + { + "mutex_wait_ns": 5746400, + "serialization_ns": 2900, + "serialized_bytes": 613, + "statement_ns": 2534100, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3500, + "serialized_bytes": 613, + "statement_ns": 2794200, + "success": true + }, + { + "mutex_wait_ns": 5356100, + "serialization_ns": 5000, + "serialized_bytes": 1040, + "statement_ns": 2660500, + "success": true + }, + { + "mutex_wait_ns": 2675300, + "serialization_ns": 4400, + "serialized_bytes": 1040, + "statement_ns": 2441300, + "success": true + }, + { + "mutex_wait_ns": 2452600, + "serialization_ns": 5300, + "serialized_bytes": 1079, + "statement_ns": 2613600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5500, + "serialized_bytes": 1087, + "statement_ns": 4118000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7600, + "serialized_bytes": 1303, + "statement_ns": 2926200, + "success": true + }, + { + "mutex_wait_ns": 9714700, + "serialization_ns": 5000, + "serialized_bytes": 1079, + "statement_ns": 2307300, + "success": true + }, + { + "mutex_wait_ns": 2161200, + "serialization_ns": 3300, + "serialized_bytes": 611, + "statement_ns": 3116100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4400, + "serialized_bytes": 611, + "statement_ns": 2472500, + "success": true + }, + { + "mutex_wait_ns": 5623600, + "serialization_ns": 6700, + "serialized_bytes": 1087, + "statement_ns": 2648100, + "success": true + }, + { + "mutex_wait_ns": 2667400, + "serialization_ns": 5000, + "serialized_bytes": 1036, + "statement_ns": 2486400, + "success": true + }, + { + "mutex_wait_ns": 2496500, + "serialization_ns": 7100, + "serialized_bytes": 1303, + "statement_ns": 3479100, + "success": true + }, + { + "mutex_wait_ns": 3495600, + "serialization_ns": 7100, + "serialized_bytes": 1075, + "statement_ns": 2252700, + "success": true + }, + { + "mutex_wait_ns": 2092400, + "serialization_ns": 3600, + "serialized_bytes": 611, + "statement_ns": 3322600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4700, + "serialized_bytes": 611, + "statement_ns": 2712800, + "success": true + }, + { + "mutex_wait_ns": 6070700, + "serialization_ns": 6400, + "serialized_bytes": 1083, + "statement_ns": 2400500, + "success": true + }, + { + "mutex_wait_ns": 2412700, + "serialization_ns": 5500, + "serialized_bytes": 1036, + "statement_ns": 2442400, + "success": true + }, + { + "mutex_wait_ns": 2457700, + "serialization_ns": 6600, + "serialized_bytes": 1299, + "statement_ns": 2619700, + "success": true + }, + { + "mutex_wait_ns": 2636100, + "serialization_ns": 5600, + "serialized_bytes": 1075, + "statement_ns": 4960900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6700, + "serialized_bytes": 1083, + "statement_ns": 3565900, + "success": true + }, + { + "mutex_wait_ns": 8394700, + "serialization_ns": 2900, + "serialized_bytes": 611, + "statement_ns": 2874600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5100, + "serialized_bytes": 611, + "statement_ns": 2319600, + "success": true + }, + { + "mutex_wait_ns": 5223500, + "serialization_ns": 6800, + "serialized_bytes": 1299, + "statement_ns": 2931300, + "success": true + }, + { + "mutex_wait_ns": 2949400, + "serialization_ns": 4900, + "serialized_bytes": 1036, + "statement_ns": 2551400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5800, + "serialized_bytes": 1075, + "statement_ns": 2529500, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5700, + "serialized_bytes": 1083, + "statement_ns": 2993200, + "success": true + }, + { + "mutex_wait_ns": 7968200, + "serialization_ns": 3300, + "serialized_bytes": 613, + "statement_ns": 2849600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4800, + "serialized_bytes": 613, + "statement_ns": 2289200, + "success": true + }, + { + "mutex_wait_ns": 5173300, + "serialization_ns": 7000, + "serialized_bytes": 1299, + "statement_ns": 2971400, + "success": true + }, + { + "mutex_wait_ns": 2989200, + "serialization_ns": 5300, + "serialized_bytes": 1040, + "statement_ns": 3964300, + "success": true + }, + { + "mutex_wait_ns": 3791600, + "serialization_ns": 4100, + "serialized_bytes": 613, + "statement_ns": 2998300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5200, + "serialized_bytes": 613, + "statement_ns": 2225000, + "success": true + }, + { + "mutex_wait_ns": 5257500, + "serialization_ns": 6800, + "serialized_bytes": 1079, + "statement_ns": 2348200, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 7200, + "serialized_bytes": 1087, + "statement_ns": 2620400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5800, + "serialized_bytes": 1303, + "statement_ns": 2520600, + "success": true + }, + { + "mutex_wait_ns": 7549400, + "serialization_ns": 6000, + "serialized_bytes": 1040, + "statement_ns": 3372000, + "success": true + }, + { + "mutex_wait_ns": 3223400, + "serialization_ns": 3400, + "serialized_bytes": 613, + "statement_ns": 2885300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 3900, + "serialized_bytes": 613, + "statement_ns": 2245100, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4900, + "serialized_bytes": 1040, + "statement_ns": 2524000, + "success": true + }, + { + "mutex_wait_ns": 7697700, + "serialization_ns": 7700, + "serialized_bytes": 1079, + "statement_ns": 2458800, + "success": true + }, + { + "mutex_wait_ns": 2475600, + "serialization_ns": 5000, + "serialized_bytes": 1079, + "statement_ns": 2520600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6000, + "serialized_bytes": 1087, + "statement_ns": 3749800, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 5600, + "serialized_bytes": 1303, + "statement_ns": 2908000, + "success": true + }, + { + "mutex_wait_ns": 9239300, + "serialization_ns": 8200, + "serialized_bytes": 1087, + "statement_ns": 2490900, + "success": true + }, + { + "mutex_wait_ns": 2338100, + "serialization_ns": 6100, + "serialized_bytes": 613, + "statement_ns": 4005500, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4100, + "serialized_bytes": 613, + "statement_ns": 2633900, + "success": true + }, + { + "mutex_wait_ns": 6666600, + "serialization_ns": 8100, + "serialized_bytes": 1303, + "statement_ns": 2808400, + "success": true + }, + { + "mutex_wait_ns": 2825500, + "serialization_ns": 4800, + "serialized_bytes": 1040, + "statement_ns": 2535300, + "success": true + }, + { + "mutex_wait_ns": 2438800, + "serialization_ns": 4300, + "serialized_bytes": 611, + "statement_ns": 2884400, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4400, + "serialized_bytes": 611, + "statement_ns": 2908100, + "success": true + }, + { + "mutex_wait_ns": 5825100, + "serialization_ns": 5700, + "serialized_bytes": 1079, + "statement_ns": 3477000, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6300, + "serialized_bytes": 1087, + "statement_ns": 2454600, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6400, + "serialized_bytes": 1303, + "statement_ns": 2360400, + "success": true + }, + { + "mutex_wait_ns": 8352000, + "serialization_ns": 6200, + "serialized_bytes": 1036, + "statement_ns": 2349400, + "success": true + }, + { + "mutex_wait_ns": 2190500, + "serialization_ns": 3400, + "serialized_bytes": 611, + "statement_ns": 2600300, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 3900, + "serialized_bytes": 611, + "statement_ns": 2741700, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 4800, + "serialized_bytes": 1036, + "statement_ns": 2120100, + "success": true + }, + { + "mutex_wait_ns": 7507200, + "serialization_ns": 7000, + "serialized_bytes": 1075, + "statement_ns": 2423800, + "success": true + }, + { + "mutex_wait_ns": 2438700, + "serialization_ns": 5400, + "serialized_bytes": 1075, + "statement_ns": 2752000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4900, + "serialized_bytes": 1083, + "statement_ns": 2331800, + "success": true + }, + { + "mutex_wait_ns": 5125300, + "serialization_ns": 6000, + "serialized_bytes": 1083, + "statement_ns": 2396800, + "success": true + }, + { + "mutex_wait_ns": 2414600, + "serialization_ns": 5400, + "serialized_bytes": 1299, + "statement_ns": 2620900, + "success": true + }, + { + "mutex_wait_ns": 2642800, + "serialization_ns": 5100, + "serialized_bytes": 1299, + "statement_ns": 3171600, + "success": true + }, + { + "mutex_wait_ns": 2588700, + "serialization_ns": 3500, + "serialized_bytes": 611, + "statement_ns": 2777700, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4200, + "serialized_bytes": 611, + "statement_ns": 2790900, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4900, + "serialized_bytes": 1036, + "statement_ns": 2208800, + "success": true + }, + { + "mutex_wait_ns": 7757100, + "serialization_ns": 3500, + "serialized_bytes": 611, + "statement_ns": 3603600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 4200, + "serialized_bytes": 611, + "statement_ns": 2751500, + "success": true + }, + { + "mutex_wait_ns": 6381900, + "serialization_ns": 5500, + "serialized_bytes": 1075, + "statement_ns": 3382000, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 6000, + "serialized_bytes": 1083, + "statement_ns": 3415400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 5400, + "serialized_bytes": 1299, + "statement_ns": 3468000, + "success": true + }, + { + "mutex_wait_ns": 10319500, + "serialization_ns": 5900, + "serialized_bytes": 1036, + "statement_ns": 5376300, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6400, + "serialized_bytes": 1075, + "statement_ns": 2577600, + "success": true + }, + { + "mutex_wait_ns": 100, + "serialization_ns": 7100, + "serialized_bytes": 1083, + "statement_ns": 2749400, + "success": true + }, + { + "mutex_wait_ns": 0, + "serialization_ns": 6300, + "serialized_bytes": 1299, + "statement_ns": 3914500, + "success": true + } + ] + }, + "shutdown_elapsed_ns": 701900, + "sqlite": { + "busy_timeout_ms": 5000, + "cache_size": -2000, + "compile_options": [ + "ATOMIC_INTRINSICS=0", + "COMPILER=msvc-1944", + "DEFAULT_AUTOVACUUM", + "DEFAULT_CACHE_SIZE=-2000", + "DEFAULT_FILE_FORMAT=4", + "DEFAULT_FOREIGN_KEYS", + "DEFAULT_JOURNAL_SIZE_LIMIT=-1", + "DEFAULT_MMAP_SIZE=0", + "DEFAULT_PAGE_SIZE=4096", + "DEFAULT_PCACHE_INITSZ=20", + "DEFAULT_RECURSIVE_TRIGGERS", + "DEFAULT_SECTOR_SIZE=4096", + "DEFAULT_SYNCHRONOUS=2", + "DEFAULT_WAL_AUTOCHECKPOINT=1000", + "DEFAULT_WAL_SYNCHRONOUS=2", + "DEFAULT_WORKER_THREADS=0", + "DIRECT_OVERFLOW_READ", + "ENABLE_API_ARMOR", + "ENABLE_COLUMN_METADATA", + "ENABLE_DBSTAT_VTAB", + "ENABLE_FTS3", + "ENABLE_FTS3_PARENTHESIS", + "ENABLE_FTS5", + "ENABLE_LOAD_EXTENSION", + "ENABLE_MEMORY_MANAGEMENT", + "ENABLE_RTREE", + "ENABLE_STAT4", + "HAVE_ISNAN", + "MALLOC_SOFT_LIMIT=1024", + "MAX_ATTACHED=10", + "MAX_COLUMN=2000", + "MAX_COMPOUND_SELECT=500", + "MAX_DEFAULT_PAGE_SIZE=8192", + "MAX_EXPR_DEPTH=1000", + "MAX_FUNCTION_ARG=1000", + "MAX_LENGTH=1000000000", + "MAX_LIKE_PATTERN_LENGTH=50000", + "MAX_MMAP_SIZE=0x7fff0000", + "MAX_PAGE_COUNT=0xfffffffe", + "MAX_PAGE_SIZE=65536", + "MAX_SQL_LENGTH=1000000000", + "MAX_TRIGGER_DEPTH=1000", + "MAX_VARIABLE_NUMBER=32766", + "MAX_VDBE_OP=250000000", + "MAX_WORKER_THREADS=8", + "MUTEX_W32", + "SOUNDEX", + "SYSTEM_MALLOC", + "TEMP_STORE=1", + "THREADSAFE=1", + "USE_URI" + ], + "journal_mode": "wal", + "page_size": 4096, + "synchronous": 2, + "version": "3.51.1", + "wal_autocheckpoint": 1000 + }, + "status": "PASS", + "storage": "fresh temporary file-backed archive; no PRAGMA overrides", + "successful": 32, + "transport": "TLS", + "wall_budget_exceeded": false + } + ], + "not_run": { + "disk_flush_count": "not observed", + "gui_android": "outside harness", + "production_performance": "synthetic test-only harness", + "queue_wait": "no writer queue exists", + "sqlite_busy_wait_separate": "included in statement elapsed" + }, + "profile": "release", + "runtime": "multi_thread", + "schema": 1, + "status": "PASS", + "timer_network_positive_control": { + "reason": "intentional blocking control requires current-thread runtime", + "status": "NOTRUN" + }, + "workers": 2 + }, + "cleanup_uncertain": false + } + ], + "cleanup_uncertain": false +} diff --git a/docs/superpowers/plans/2026-11-06-archive-measurement.md b/docs/superpowers/plans/2026-11-06-archive-measurement.md index b52821e..2e48f8f 100644 --- a/docs/superpowers/plans/2026-11-06-archive-measurement.md +++ b/docs/superpowers/plans/2026-11-06-archive-measurement.md @@ -39,7 +39,10 @@ Files: diagnostic submodules, `scripts/measure-archive.py`, runner unit tests. ### Task 3: Hosted evidence and proposal Files: measurement workflow, `docs/ARCHIVE_RESPONSIVENESS.md`, allowlisted result JSON. -- [ ] Review complete source before a single branch push/dispatch, reconcile receipts. -- [ ] Obtain actual hosted Linux/Windows debug/release results and verify artifact provenance. -- [ ] Document bounded writer ordering, backpressure, cancellation/restart/error guarantees from evidence. -- [ ] Independent whole-branch review, affected tests, final PR referencing #28 and exact remote/body readback. +- [x] Review complete source before branch publication and explicit dispatch; reconcile receipts. +- [x] Obtain actual hosted Linux/Windows debug/release results and verify artifact provenance. +- [x] Document bounded writer ordering, backpressure, cancellation/restart/error guarantees from evidence. +- [x] Independent whole-branch/result review, affected checks, and one PR #30 referencing #28. + +Publication receipts (exact head, readiness, checks and final readback) are maintained +in the PR description; no merge or release is part of this plan. From 1ff7ad713f72796aca583d1bae0cececc3e12080 Mon Sep 17 00:00:00 2001 From: Mateusz Dalke <150788324+dalkedev@users.noreply.github.com> Date: Fri, 6 Nov 2026 21:25:10 +0000 Subject: [PATCH 7/8] test: allow absent network samples in a zero-width probe window Readiness already requires a successful warmup echo; the OS thread need not record another sample before drain stops. Keep all NOTRUN/window/control assertions and preserve measured-source/runtime-prefix provenance. --- crates/scope-core/src/diagnostics/probes.rs | 3 ++- docs/ARCHIVE_RESPONSIVENESS.md | 25 +++++++++++++++++-- ...ive-responsiveness-2026-11-06-summary.json | 13 +++++++++- 3 files changed, 37 insertions(+), 4 deletions(-) diff --git a/crates/scope-core/src/diagnostics/probes.rs b/crates/scope-core/src/diagnostics/probes.rs index 359ecae..a98578b 100644 --- a/crates/scope-core/src/diagnostics/probes.rs +++ b/crates/scope-core/src/diagnostics/probes.rs @@ -355,7 +355,8 @@ fn draining_real_probes_does_not_turn_an_empty_window_into_coverage() { let report = probes.finish(boundary, boundary).await; assert!(report.covered()); assert!(!report.timer.samples.is_empty()); - assert!(!report.network.samples.is_empty()); + // The warmup echo establishes readiness. A zero-width workload need + // not schedule another OS-thread attempt during drain; empty is valid. assert_eq!(report.timer.in_window_samples, 0); assert_eq!(report.network.in_window_samples, 0); assert_eq!(report.timer.window_status, "NOTRUN"); diff --git a/docs/ARCHIVE_RESPONSIVENESS.md b/docs/ARCHIVE_RESPONSIVENESS.md index b62843b..b71823d 100644 --- a/docs/ARCHIVE_RESPONSIVENESS.md +++ b/docs/ARCHIVE_RESPONSIVENESS.md @@ -135,8 +135,13 @@ artifact digests before extracting the sole allowlisted `measurement.json` file. The summary records artifact IDs/digests and raw JSON SHA-256 values. All runtime reports passed the strict schema validator, source/clean-tree/run/attempt/sample identity checks and exact evidence counts. Independent review recalculated all -16 groups and every displayed table cell. The final PR may add documentation; -its measurement-source hashes must continue to match this measured commit. +16 groups and every displayed table cell. Recorded whole-file hashes identify +the measured commit. Subsequent changes add documentation/results and correct +one ordinary-CI assertion in the probe regression tests, described below. All +other recorded source files match; the probe runtime implementation is byte- +identical before its first `#[test]` function. The summary defines that UTF-8 +prefix boundary precisely and records its verified SHA-256. No timing logic, +threshold, window filter or workload changed after the measured commit. ### Descriptive timings (milliseconds) @@ -212,6 +217,22 @@ This is a harness smoke check, not comparative performance evidence. GUI/Android, real captures, external endpoints, sustained/large-body workloads, fsync counts, isolated storage latency and production performance: **NOT RUN**. +## Zero-width regression test correction + +The [macOS job on the first results commit](https://github.com/dalkedev/scope/actions/runs/42295532143/job/128159662751) +failed only `draining_real_probes_does_not_turn_an_empty_window_into_coverage`: +its assertion required an active network sample during approximately 20ms of +drain even though the workload window has zero width. `Probes::start` already +proves a successful warmup echo. The OS thread may observe the stop flag before +its next active attempt, so an empty collector is valid and must remain NOT RUN. + +Only that incidental nonempty-network assertion was removed. Real socket +readiness, timer observation, both zero in-window counts, both NOTRUN states and +false-control rejection remain checked. Deterministic interval/empty-collector +regressions and the four hosted blocking controls remain unchanged. This is a +normal-CI test correction, not a measurement change or timeout increase. The +summary preserves the failed commit/job and the unchanged-runtime-prefix proof. + ## Bounded writer proposal (not implemented) Start with scheduling isolation, not transaction batching: one blocking writer diff --git a/docs/benchmarks/archive-responsiveness-2026-11-06-summary.json b/docs/benchmarks/archive-responsiveness-2026-11-06-summary.json index 4bc0dbd..bc62ac8 100644 --- a/docs/benchmarks/archive-responsiveness-2026-11-06-summary.json +++ b/docs/benchmarks/archive-responsiveness-2026-11-06-summary.json @@ -1333,5 +1333,16 @@ "artifact_id": 13541022569, "artifact_zip_sha256": "e0b2f3c65fd43e4fe179258d6a6dfd76a863c8c80059467f061e8ee3239c125d" } - ] + ], + "postmeasurement_test_only_change": { + "file": "crates/scope-core/src/diagnostics/probes.rs", + "test": "draining_real_probes_does_not_turn_an_empty_window_into_coverage", + "reason": "Remove an incidental nonempty network-sample assumption for a zero-width window; retain all window, NOTRUN and false-control assertions.", + "failure_commit": "1f6c8dd9462fe7633a9c3039b6a906ced96cbdcb", + "failure_job_url": "https://github.com/dalkedev/scope/actions/runs/42295532143/job/128159662751", + "unchanged_runtime_prefix": { + "definition": "UTF-8 file bytes before the first literal newline + #[test] + newline; separator and subsequent test functions excluded.", + "sha256": "bacc8d874415564f56f69356c100d3ede403486d56b9e9bec80086b9a0874802" + } + } } From 697f1d5a728d420cdeb998b0e343782a4248010b Mon Sep 17 00:00:00 2001 From: Mateusz Dalke <150788324+dalkedev@users.noreply.github.com> Date: Fri, 6 Nov 2026 21:46:38 +0000 Subject: [PATCH 8/8] fix: reap bounded process trees on parent cancellation Share finite deadline/exception cleanup and preserve cancellation propagation. Add disposable-tree SIGINT/exception regressions and a Python-only hosted gate without repeating archive measurements. --- .github/workflows/archive-measurement.yml | 17 +- .github/workflows/har-compare-action.yml | 12 +- docs/ARCHIVE_RESPONSIVENESS.md | 36 +++- ...ive-responsiveness-2026-11-06-summary.json | 9 + scripts/measure-archive.py | 72 +++++--- scripts/tests/test_measure_archive.py | 11 ++ .../tests/test_measure_archive_processes.py | 167 ++++++++++++++++++ 7 files changed, 293 insertions(+), 31 deletions(-) create mode 100644 scripts/tests/test_measure_archive_processes.py diff --git a/.github/workflows/archive-measurement.yml b/.github/workflows/archive-measurement.yml index c65c982..c92a924 100644 --- a/.github/workflows/archive-measurement.yml +++ b/.github/workflows/archive-measurement.yml @@ -2,6 +2,10 @@ name: Synthetic archive measurement on: workflow_dispatch: workflow_call: + inputs: + runner_tests_only: + type: boolean + default: false permissions: contents: read concurrency: @@ -9,9 +13,9 @@ concurrency: cancel-in-progress: false jobs: archive-measurement: - name: Archive measurement ${{ matrix.os }} + name: ${{ inputs.runner_tests_only && 'Runner regressions' || 'Archive measurement' }} ${{ matrix.os }} runs-on: ${{ matrix.os }} - timeout-minutes: 45 + timeout-minutes: ${{ inputs.runner_tests_only && 5 || 45 }} strategy: fail-fast: false matrix: @@ -23,18 +27,21 @@ jobs: - uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 with: python-version: '3.12' - - uses: dtolnay/rust-toolchain@b725eda525362e7cf34af9a7243cac1e3f01a7ec + - if: ${{ !inputs.runner_tests_only }} + uses: dtolnay/rust-toolchain@b725eda525362e7cf34af9a7243cac1e3f01a7ec with: toolchain: 1.99.1 - name: Runner regressions - run: python -m unittest discover -s scripts/tests -p test_measure_archive.py + run: python -m unittest discover -s scripts/tests -p 'test_measure_archive*.py' - name: Evidence detector regressions + if: ${{ !inputs.runner_tests_only }} run: | cargo test --locked -p scope-core --lib diagnostics:: - name: Measure fresh synthetic archives (debug and release separately) + if: ${{ !inputs.runner_tests_only }} run: python scripts/measure-archive.py --profiles debug release --samples 3 --workers 0 2 --output-dir .runtime/archive-measurement - name: Upload numeric synthetic diagnostics only - if: always() + if: ${{ always() && !inputs.runner_tests_only }} uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 with: name: archive-measurement-${{ matrix.os }}-${{ github.sha }} diff --git a/.github/workflows/har-compare-action.yml b/.github/workflows/har-compare-action.yml index db4376b..6e153f1 100644 --- a/.github/workflows/har-compare-action.yml +++ b/.github/workflows/har-compare-action.yml @@ -16,7 +16,7 @@ on: diagnostic: description: Explicit diagnostic (archive measurement never runs the HAR consumer) type: choice - options: [har-composite, archive-measurement] + options: [har-composite, archive-measurement, runner-regressions] required: false default: har-composite @@ -29,7 +29,7 @@ concurrency: jobs: consumer: - if: github.event_name != 'workflow_dispatch' || inputs.diagnostic != 'archive-measurement' + if: github.event_name != 'workflow_dispatch' || (inputs.diagnostic != 'archive-measurement' && inputs.diagnostic != 'runner-regressions') name: Composite ${{ matrix.scenario }} runs-on: ubuntu-22.04 timeout-minutes: 5 @@ -85,3 +85,11 @@ jobs: uses: ./.github/workflows/archive-measurement.yml permissions: contents: read + + runner-regressions: + if: github.event_name == 'workflow_dispatch' && inputs.diagnostic == 'runner-regressions' + uses: ./.github/workflows/archive-measurement.yml + with: + runner_tests_only: true + permissions: + contents: read diff --git a/docs/ARCHIVE_RESPONSIVENESS.md b/docs/ARCHIVE_RESPONSIVENESS.md index b71823d..2a4cce1 100644 --- a/docs/ARCHIVE_RESPONSIVENESS.md +++ b/docs/ARCHIVE_RESPONSIVENESS.md @@ -36,7 +36,9 @@ or native-security changes, and a 45-minute job limit. Each runner exports one allowlisted numeric JSON artifact; compiler logs, archives and temporary CA keys are excluded. The Python runner has an overall 30-minute budget, bounded builds and child processes, and kills/reaps children on hard timeout. A failure to -establish process-tree cleanup ends further sampling. +establish process-tree cleanup ends further sampling. Parent cancellation or an +exception also invokes the same bounded tree termination/reaping before the +original exception is reraised; uncertain cleanup is attached as a fixed note. ## Workload and interpretation @@ -137,8 +139,9 @@ reports passed the strict schema validator, source/clean-tree/run/attempt/sample identity checks and exact evidence counts. Independent review recalculated all 16 groups and every displayed table cell. Recorded whole-file hashes identify the measured commit. Subsequent changes add documentation/results and correct -one ordinary-CI assertion in the probe regression tests, described below. All -other recorded source files match; the probe runtime implementation is byte- +one ordinary-CI assertion in the probe regression tests, described below. The later runner cancellation fix and Python-only test workflow are recorded +as explicit source exceptions in the summary; other recorded sources match. +The probe runtime implementation is byte- identical before its first `#[test]` function. The summary defines that UTF-8 prefix boundary precisely and records its verified SHA-256. No timing logic, threshold, window filter or workload changed after the measured commit. @@ -233,6 +236,33 @@ regressions and the four hosted blocking controls remain unchanged. This is a normal-CI test correction, not a measurement change or timeout increase. The summary preserves the failed commit/job and the unchanged-runtime-prefix proof. +## Parent cancellation cleanup follow-up + +The original runner cleaned detached child trees only when its deadline expired. +A parent SIGINT/KeyboardInterrupt could leave Cargo or a test process running. +The runner now shares finite tree termination and direct-child reaping between +TimeoutExpired and parent BaseException paths, then reraises the original parent +exception. Windows taskkill failure/timeout still marks cleanup uncertainty; +direct-child fallback does not falsely establish descendant cleanup. The helper +uses at most 10 seconds for taskkill and 10 seconds for reaping per attempt. + +Disposable-process regressions launch a sleeping child and descendant, prove +actual POSIX SIGINT cleanup and preserved exception propagation, and always clean +the fixture's own recorded PIDs/groups. Native Windows tests use injected Python +KeyboardInterrupt/RuntimeError with real Windows process trees; console Ctrl+C +coverage is NOT RUN. A manually selected `runner-regressions` choice in the HAR +entry point runs only Python tests on Linux/Windows, with a five-minute job limit: + +```sh +gh workflow run har-compare-action.yml --ref YOUR_BRANCH -f diagnostic=runner-regressions +``` + +Rust setup/builds, measurements and report upload are skipped for this choice. +The successful-process output/status contract and Rust measurement implementation +are unchanged. Existing Linux/Windows results remain pinned to measured source +`19aec4f`; no long benchmark rerun is implied by this cleanup-only correction. +Exact follow-up test receipts and head are recorded in the PR description. + ## Bounded writer proposal (not implemented) Start with scheduling isolation, not transaction batching: one blocking writer diff --git a/docs/benchmarks/archive-responsiveness-2026-11-06-summary.json b/docs/benchmarks/archive-responsiveness-2026-11-06-summary.json index bc62ac8..7b30b82 100644 --- a/docs/benchmarks/archive-responsiveness-2026-11-06-summary.json +++ b/docs/benchmarks/archive-responsiveness-2026-11-06-summary.json @@ -1344,5 +1344,14 @@ "definition": "UTF-8 file bytes before the first literal newline + #[test] + newline; separator and subsequent test functions excluded.", "sha256": "bacc8d874415564f56f69356c100d3ede403486d56b9e9bec80086b9a0874802" } + }, + "postmeasurement_runner_cancellation_change": { + "reason": "Shared bounded tree termination/reaping on deadline and parent cancellation/exception; cancellation is reraised. Normal outputs, measurement commands and Rust workload/timing implementation are unchanged.", + "files_sha256": { + "scripts/measure-archive.py": "45485241ffb7f0c0384be7e5f88ca141d3c8235127cdd8491af1c04942bffd8e", + ".github/workflows/archive-measurement.yml": "de71fa332d5c4e59dbfc5b8891bda62db5431f90a5bdd2137aa03fc1b0125e26", + ".github/workflows/har-compare-action.yml": "22022e14f726f7d51cf127b1935b9283cff8f016c49d2caf6abbc781ab384343" + }, + "validation": "Disposable child/descendant regressions; actual POSIX SIGINT and injected Python cancellation/exception. Windows console Ctrl+C is not claimed." } } diff --git a/scripts/measure-archive.py b/scripts/measure-archive.py index b24f24c..b30c13f 100644 --- a/scripts/measure-archive.py +++ b/scripts/measure-archive.py @@ -20,34 +20,64 @@ WINDOWS = os.name == 'nt' +def terminate_and_reap(child): + """Bounded cleanup of this owned process tree; return cleanup uncertainty.""" + uncertain = False + if WINDOWS: + try: + killed = subprocess.run(['taskkill', '/PID', str(child.pid), '/T', '/F'], + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, + timeout=10, check=False) + uncertain = killed.returncode != 0 + except (OSError, subprocess.TimeoutExpired): + uncertain = True # Direct kill cannot confirm descendant cleanup. + else: + try: + os.killpg(child.pid, signal.SIGKILL) + except ProcessLookupError: + pass + except OSError: + uncertain = True + try: + if child.poll() is None: + child.kill() + except ProcessLookupError: + pass + except OSError: + uncertain = True + try: + child.wait(timeout=10) + except (OSError, subprocess.TimeoutExpired): + uncertain = True + return uncertain + + def run_bounded(command, cwd, env, timeout): - """Kill/reap after a hard deadline; expose uncertainty about descendants.""" + """Own the child tree until normal completion, deadline or parent exception.""" kwargs = {'start_new_session': True} if os.name != 'nt' else {'creationflags': subprocess.CREATE_NEW_PROCESS_GROUP} with tempfile.TemporaryFile() as output: - child = subprocess.Popen(command, cwd=cwd, env=env, stdout=output, stderr=subprocess.STDOUT, **kwargs) + child = None timed_out = False cleanup_uncertain = False try: - child.wait(timeout=timeout) - except subprocess.TimeoutExpired: - timed_out = True - if WINDOWS: - try: - killed = subprocess.run(['taskkill', '/PID', str(child.pid), '/T', '/F'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=10, check=False) - cleanup_uncertain = killed.returncode != 0 - except (OSError, subprocess.TimeoutExpired): - cleanup_uncertain = True # Direct kill cannot confirm descendant cleanup. - else: + child = subprocess.Popen(command, cwd=cwd, env=env, stdout=output, stderr=subprocess.STDOUT, **kwargs) + try: + child.wait(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + cleanup_uncertain = terminate_and_reap(child) + output.seek(0) + # Cargo JSON is bounded here; do not export compiler output or local paths. + captured = output.read(16 * 1024 * 1024).decode('utf-8', errors='replace') + except BaseException as error: + if child is not None: try: - os.killpg(child.pid, signal.SIGKILL) - except ProcessLookupError: - pass - if child.poll() is None: - child.kill() - child.wait(timeout=10) - output.seek(0) - # Cargo JSON is bounded here; do not export compiler output or local paths. - captured = output.read(16 * 1024 * 1024).decode('utf-8', errors='replace') + uncertain = terminate_and_reap(child) + except BaseException: + uncertain = True + if uncertain: + error.add_note('Process-tree termination or reaping could not be fully confirmed.') + raise return {'status': 'TIMEOUT' if timed_out else ('PASS' if child.returncode == 0 else 'FAIL'), 'returncode': child.returncode, 'output': captured, 'cleanup_uncertain': cleanup_uncertain} diff --git a/scripts/tests/test_measure_archive.py b/scripts/tests/test_measure_archive.py index 0e8a161..14977b9 100644 --- a/scripts/tests/test_measure_archive.py +++ b/scripts/tests/test_measure_archive.py @@ -49,6 +49,17 @@ def values(sample): class MeasurementRunnerTests(unittest.TestCase): + def test_normal_completion_preserves_output_and_exit_status(self): + with tempfile.TemporaryDirectory() as directory: + for code, status in [(0, 'PASS'), (3, 'FAIL')]: + result = measure.run_bounded([sys.executable, '-c', + f"import sys; print('synthetic output'); sys.exit({code})"], + Path(directory), {}, 5) + self.assertEqual(result['status'], status) + self.assertEqual(result['returncode'], code) + self.assertEqual(result['output'].strip(), 'synthetic output') + self.assertFalse(result['cleanup_uncertain']) + def test_hard_deadline_kills_and_reaps_stalled_child(self): with tempfile.TemporaryDirectory() as directory: result = measure.run_bounded([sys.executable, '-c', 'import time; time.sleep(10)'], Path(directory), {}, .1) diff --git a/scripts/tests/test_measure_archive_processes.py b/scripts/tests/test_measure_archive_processes.py new file mode 100644 index 0000000..12f0976 --- /dev/null +++ b/scripts/tests/test_measure_archive_processes.py @@ -0,0 +1,167 @@ +"""Disposable-process integration regressions; no application or external endpoints.""" +import ctypes +import json +import os +from pathlib import Path +import signal +import subprocess +import sys +import tempfile +import time +import unittest + +MODULE = Path(__file__).parents[1] / 'measure-archive.py' +DRIVER = r''' +import importlib.util,json,os,subprocess,sys,time +from pathlib import Path +module,folder,mode=sys.argv[1:] +folder=Path(folder) +spec=importlib.util.spec_from_file_location('measure',module) +measure=importlib.util.module_from_spec(spec);spec.loader.exec_module(measure) +real_popen=subprocess.Popen +owned=[] +def observed_popen(*args,**kwargs): + child=real_popen(*args,**kwargs) + if not owned: + owned.append(child) + (folder/'launch.tmp').write_text(json.dumps({'pid':child.pid})) + os.replace(folder/'launch.tmp',folder/'launch.json') + real_wait=child.wait + first=[True] + def interrupted_wait(*args,**kwargs): + if first[0]: + first[0]=False + (folder/'waiting').write_text('ready') + if mode!='signal': + deadline=time.monotonic()+5 + while not (folder/'tree.json').exists(): + if time.monotonic()>deadline:raise RuntimeError('fixture readiness timeout') + time.sleep(.01) + if mode=='exception':raise RuntimeError('synthetic parent exception') + raise KeyboardInterrupt() + return real_wait(*args,**kwargs) + child.wait=interrupted_wait + return child +measure.subprocess.Popen=observed_popen +sleeper="import subprocess,sys,os,json,time; from pathlib import Path; descendant=subprocess.Popen([sys.executable,'-c','import time; time.sleep(60)']); Path(sys.argv[1]+'.tmp').write_text(json.dumps({'child':os.getpid(),'descendant':descendant.pid})); os.replace(sys.argv[1]+'.tmp',sys.argv[1]); time.sleep(60)" +try: + measure.run_bounded([sys.executable,'-c',sleeper,str(folder/'tree.json')],folder,os.environ.copy(),30) +except BaseException as error: + (folder/'result.json').write_text(json.dumps({'exception':type(error).__name__,'returncode':owned[0].returncode})) + raise +''' + + +def running(pid): + if os.name == 'nt': + from ctypes import wintypes + kernel = ctypes.WinDLL('kernel32', use_last_error=True) + kernel.OpenProcess.argtypes = [wintypes.DWORD, wintypes.BOOL, wintypes.DWORD] + kernel.OpenProcess.restype = wintypes.HANDLE + kernel.WaitForSingleObject.argtypes = [wintypes.HANDLE, wintypes.DWORD] + kernel.WaitForSingleObject.restype = wintypes.DWORD + kernel.CloseHandle.argtypes = [wintypes.HANDLE] + handle = kernel.OpenProcess(0x100000, False, pid) # SYNCHRONIZE, fixture PIDs only. + if not handle: + if ctypes.get_last_error() in (87, 1168): + return False + raise ctypes.WinError(ctypes.get_last_error()) + try: + state = kernel.WaitForSingleObject(handle, 0) + if state not in (0, 258): + raise OSError('fixture process state unavailable') + return state == 258 + finally: + kernel.CloseHandle(handle) + try: + os.kill(pid, 0) + except ProcessLookupError: + return False + # A terminated adopted descendant may briefly await the OS reaper. + status = subprocess.run(['ps', '-o', 'stat=', '-p', str(pid)], capture_output=True, + text=True, timeout=2, check=False).stdout.strip() + return bool(status) and not status.startswith('Z') + + +def cleanup_fixture(driver, folder): + """Always clean only groups/PIDs created and journaled by this fixture.""" + try: + primary = None + pids = [] + if (folder/'launch.json').exists(): + primary = json.loads((folder/'launch.json').read_text())['pid'] + pids.append(primary) + if (folder/'tree.json').exists(): + pids.extend(json.loads((folder/'tree.json').read_text()).values()) + for pid in set(pids): + if type(pid) is not int or pid <= 1: + raise AssertionError('invalid disposable fixture PID') + if os.name == 'nt': + for pid in set(pids): + if running(pid): + try: + subprocess.run(['taskkill', '/PID', str(pid), '/T', '/F'], + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, + timeout=5, check=False) + except (OSError, subprocess.TimeoutExpired): + pass + if running(pid): + # Fallback only for these exact disposable fixture PIDs. + try: + os.kill(pid, signal.SIGTERM) + except ProcessLookupError: + pass + elif primary is not None: + try: + os.killpg(primary, signal.SIGKILL) + except ProcessLookupError: + pass + finally: + if driver.poll() is None: + driver.kill() + driver.wait(timeout=5) + + + +class ProcessOwnershipTests(unittest.TestCase): + def exercise(self, mode, expected): + with tempfile.TemporaryDirectory() as directory: + folder = Path(directory) + script = folder/'driver.py'; script.write_text(DRIVER) + options = {'start_new_session': True} if os.name != 'nt' else { + 'creationflags': subprocess.CREATE_NEW_PROCESS_GROUP} + with tempfile.TemporaryFile() as log: + driver = subprocess.Popen([sys.executable, str(script), str(MODULE.resolve()), + str(folder), mode], stdout=log, stderr=log, **options) + try: + deadline = time.monotonic()+7 + while not ((folder/'tree.json').exists() and (folder/'waiting').exists()): + if driver.poll() is not None or time.monotonic()>deadline: + self.fail('disposable process fixture failed to become ready') + time.sleep(.01) + tree = json.loads((folder/'tree.json').read_text()) + if mode == 'signal': + driver.send_signal(signal.SIGINT) + driver.wait(timeout=12) + self.assertNotEqual(driver.returncode, 0) + result = json.loads((folder/'result.json').read_text()) + self.assertEqual(result['exception'], expected) + self.assertIsNotNone(result['returncode'], 'direct child was not reaped') + self.assertFalse(running(tree['child']), 'disposable child survived cancellation') + self.assertFalse(running(tree['descendant']), 'disposable descendant survived cancellation') + finally: + cleanup_fixture(driver, folder) + + @unittest.skipIf(os.name == 'nt', 'POSIX SIGINT; Windows tests inject the Python cancellation') + def test_sigint_parent_does_not_orphan_child_or_descendant(self): + self.exercise('signal', 'KeyboardInterrupt') + + def test_keyboard_interrupt_reaps_real_child_and_terminates_descendant(self): + self.exercise('injected', 'KeyboardInterrupt') + + def test_parent_exception_reaps_real_child_and_terminates_descendant(self): + self.exercise('exception', 'RuntimeError') + + +if __name__ == '__main__': + unittest.main()