Improve

Author: owjs3901

Cargo.lock

@@ -11,14 +11,31 @@ repository = "https://github.com/dev-five-git/vespera"
 readme = "README.md"
 
 # Release profile tuned for the shipped artifacts (JNI cdylibs, server
-# binaries): thin LTO + single codegen unit trade longer release-build
-# time for faster/smaller production code.
+# binaries): FAT LTO + single codegen unit deliberately trade much
+# longer release-build time for maximum cross-crate inlining on the
+# runtime-critical paths (wire parse/serialize, dispatch, JNI
+# callbacks).  Runtime performance of the shipped artifact is
+# prioritized over build time by project policy.
+#
+# `strip = "debuginfo"` shrinks the artifact without touching the
+# exported JNI dynamic symbols (they live in `.dynsym`, not the
+# stripped debug/local symbol table).
 #
 # NEVER switch the panic strategy away from unwinding here — the JNI
 # bridge relies on `catch_unwind` to convert handler panics into `500`
 # wire responses; aborting would take down the host JVM instead.
 [profile.release]
-lto = "thin"
+lto = "fat"
+codegen-units = 1
+strip = "debuginfo"
+
+# Benchmarks must measure under the SAME codegen as the shipped release
+# artifacts (fat LTO + single codegen unit); otherwise the absolute
+# numbers reflect the default `bench` profile (no LTO, 16 codegen units)
+# instead of production.  Build time is intentionally traded for
+# representative measurements.
+[profile.bench]
+lto = "fat"
 codegen-units = 1
 
 [workspace.dependencies]

Cargo.toml

@@ -80,6 +80,16 @@ tower = { version = "0.5", features = ["util"] }
 vespera_inprocess = { workspace = true }
 # Byte-snapshot testing for 422 validation envelope contract
 insta = "1.48"
+# `Validated<T>` 422-envelope serialization before/after A/B bench.
+criterion = { version = "0.8", features = ["html_reports"] }
+# `derive` for the `#[derive(Validate)]` fixture; `email`/`url` for its
+# field validators (the workspace `garde` is `default-features = false`).
+garde = { version = "0.23", features = ["derive", "email", "url"] }
+serde_json = "1"
+
+[[bench]]
+name = "validation"
+harness = false
 
 [lints]
 workspace = true

crates/vespera/Cargo.toml

@@ -0,0 +1,144 @@
+//! VESPERA-04 before/after A/B benchmark for the `422 Unprocessable
+//! Entity` validation-envelope serialization.
+//!
+//! Both implementations serialize the **same** [`garde::Report`] to the
+//! **same** bytes (`{"errors":[{"message":...,"path":...},...]}`):
+//!
+//! - `before`: the original implementation — collect every error into an
+//!   owned `Vec<ValidationErrorOut>` (two `String` allocations per error)
+//!   and then `serde_json::to_vec`.
+//! - `after`: the shipped implementation — a fully-borrowing custom
+//!   `Serialize` chain over `&garde::Report` (zero per-error `String`
+//!   allocation, `collect_str` straight into the serializer).
+//!
+//! The delta is the per-error allocation cost VESPERA-04 removes.  Both
+//! arms assert byte-identical output so the bench can never silently
+//! drift from the real envelope contract.
+
+use std::fmt::Display;
+
+use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
+use garde::Validate;
+use serde::{Serialize, Serializer, ser::SerializeStruct};
+
+// ── Fixture: a struct whose validation fails on every field ──────────
+
+#[derive(Validate)]
+struct Sample {
+    #[garde(length(min = 3, max = 32))]
+    username: String,
+    #[garde(email)]
+    email: String,
+    #[garde(range(min = 18, max = 120))]
+    age: u8,
+    #[garde(length(min = 10))]
+    bio: String,
+    #[garde(url)]
+    homepage: String,
+}
+
+/// Produce a [`garde::Report`] with `n` failing fields by validating a
+/// deliberately-invalid `Sample` and truncating the report's iteration
+/// in the benchmarked closures (we just validate the whole struct; it
+/// yields 5 errors — representative of a realistic multi-error 422).
+fn failing_report() -> garde::Report {
+    let sample = Sample {
+        username: "x".to_owned(),         // too short
+        email: "not-an-email".to_owned(), // invalid
+        age: 200,                         // out of range
+        bio: "short".to_owned(),          // too short
+        homepage: "nope".to_owned(),      // invalid url
+    };
+    sample.validate().expect_err("sample must fail validation")
+}
+
+// ── AFTER: shipped borrowing Serialize chain (mirror of validated.rs) ─
+
+fn serialize_after(report: &garde::Report) -> Vec<u8> {
+    struct DisplayValue<T>(T);
+    impl<T: Display> Serialize for DisplayValue<T> {
+        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+            s.collect_str(&self.0)
+        }
+    }
+    struct Envelope<'a>(&'a garde::Report);
+    impl Serialize for Envelope<'_> {
+        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+            let mut env = s.serialize_struct("ValidationEnvelope", 1)?;
+            env.serialize_field("errors", &Errors(self.0))?;
+            env.end()
+        }
+    }
+    struct Errors<'a>(&'a garde::Report);
+    impl Serialize for Errors<'_> {
+        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+            s.collect_seq(self.0.iter().map(|(path, err)| OneError { path, err }))
+        }
+    }
+    struct OneError<'a> {
+        path: &'a garde::Path,
+        err: &'a garde::Error,
+    }
+    impl Serialize for OneError<'_> {
+        fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+            let mut e = s.serialize_struct("ValidationError", 2)?;
+            e.serialize_field("message", &DisplayValue(self.err.message()))?;
+            e.serialize_field("path", &DisplayValue(self.path))?;
+            e.end()
+        }
+    }
+    serde_json::to_vec(&Envelope(report)).expect("infallible")
+}
+
+// ── BEFORE: original owned-Vec<String> implementation ────────────────
+
+fn serialize_before(report: &garde::Report) -> Vec<u8> {
+    #[derive(Serialize)]
+    struct ValidationErrorOut {
+        message: String,
+        path: String,
+    }
+    #[derive(Serialize)]
+    struct Envelope {
+        errors: Vec<ValidationErrorOut>,
+    }
+    let errors: Vec<ValidationErrorOut> = report
+        .iter()
+        .map(|(path, err)| ValidationErrorOut {
+            message: err.message().to_string(),
+            path: path.to_string(),
+        })
+        .collect();
+    serde_json::to_vec(&Envelope { errors }).expect("infallible")
+}
+
+fn bench_validation_envelope(c: &mut Criterion) {
+    let report = failing_report();
+
+    // Guard: the two implementations MUST produce identical bytes, so
+    // the A/B compares the same observable work — never a shortcut.
+    assert_eq!(
+        serialize_before(&report),
+        serialize_after(&report),
+        "before/after 422 envelope bytes diverged"
+    );
+
+    let n_errors = report.iter().count();
+    let mut group = c.benchmark_group("validation_envelope");
+
+    group.bench_with_input(
+        BenchmarkId::new("owned_vec_string_before", n_errors),
+        &report,
+        |b, report| b.iter(|| serialize_before(std::hint::black_box(report))),
+    );
+    group.bench_with_input(
+        BenchmarkId::new("borrowing_serialize_after", n_errors),
+        &report,
+        |b, report| b.iter(|| serialize_after(std::hint::black_box(report))),
+    );
+
+    group.finish();
+}
+
+criterion_group!(benches, bench_validation_envelope);
+criterion_main!(benches);

crates/vespera/benches/validation.rs

@@ -67,6 +67,17 @@ where
     base: axum::Router<S>,
     /// Routers to merge after `with_state()` is called
     merge_fns: Vec<fn() -> axum::Router<()>>,
+    /// Layers deferred until **after** child routers are merged.
+    ///
+    /// Axum's `Router::layer` only wraps the routes present at call
+    /// time, so applying a layer eagerly to `base` would leave
+    /// `merge`d child routes un-layered (CORS / auth / trace silently
+    /// skipped on merged routes).  Storing the layer as a closure and
+    /// replaying it in `with_state()` after the merge guarantees it
+    /// covers every route.  Each closure captures only the layer value
+    /// (`L: Send + Sync`), so the boxed trait object stays `Send + Sync`
+    /// and `VesperaRouter` keeps its previous auto-trait bounds.
+    layers: Vec<Box<dyn FnOnce(axum::Router) -> axum::Router + Send + Sync>>,
 }
 
 impl<S> VesperaRouter<S>
@@ -76,7 +87,11 @@ where
     /// Create a new `VesperaRouter` with a base router and routers to merge
     #[must_use]
     pub fn new(base: axum::Router<S>, merge_fns: Vec<fn() -> axum::Router<()>>) -> Self {
-        Self { base, merge_fns }
+        Self {
+            base,
+            merge_fns,
+            layers: Vec::new(),
+        }
     }
 
     /// Provide the state for the router and merge all child routers.
@@ -96,12 +111,24 @@ where
             router = router.merge(merge_fn());
         }
 
+        // Finally replay the deferred layers AFTER the merge so they wrap
+        // both the base routes and every merged child route.  Applied in
+        // insertion order, preserving Axum's "last layer is outermost"
+        // semantics identical to chained `Router::layer` calls.
+        for apply in self.layers {
+            router = apply(router);
+        }
+
         router
     }
 
     /// Add a layer to the router.
+    ///
+    /// The layer is **deferred** and applied in [`with_state`](Self::with_state)
+    /// after child routers are merged, so it covers merged routes as well as
+    /// the base router.
     #[must_use]
-    pub fn layer<L>(self, layer: L) -> Self
+    pub fn layer<L>(mut self, layer: L) -> Self
     where
         L: tower_layer::Layer<axum::routing::Route> + Clone + Send + Sync + 'static,
         L::Service: tower_service::Service<axum::extract::Request> + Clone + Send + Sync + 'static,
@@ -111,10 +138,9 @@ where
             Into<std::convert::Infallible> + 'static,
         <L::Service as tower_service::Service<axum::extract::Request>>::Future: Send + 'static,
     {
-        Self {
-            base: self.base.layer(layer),
-            merge_fns: self.merge_fns,
-        }
+        self.layers
+            .push(Box::new(move |router: axum::Router| router.layer(layer)));
+        self
     }
 }