Add observation for serde_bare

Cargo.toml

@@ -672,6 +672,16 @@ lto = "fat"
 codegen-units = 1
 opt-level = 3
 
+# Release-grade optimization with DWARF line info and no symbol stripping so
+# heaptrack can resolve native allocation backtraces during leak investigation.
+# Uses thin LTO and more codegen units to keep frames un-inlined and builds fast.
+[profile.profiling]
+inherits = "release"
+debug = 1
+lto = "thin"
+codegen-units = 16
+strip = false
+
 [profile.quick]
 inherits = "dev"
 debug = false          # no debug info → faster link, smaller binary

engine/packages/api-peer/src/internal.rs

@@ -62,7 +62,7 @@ pub async fn set_tracing_config(
 	body: SetTracingConfigRequest,
 ) -> Result<SetTracingConfigResponse> {
 	// Broadcast message to all services via UPS
-	let message = serde_json::to_vec(&body)?;
+	let message = rivet_util::serde::json_to_vec!(&body)?;
 
 	ctx.ups()?
 		.publish(TracingConfigSubject, &message, PublishOpts::broadcast())

engine/packages/cache/src/req_config.rs

@@ -365,7 +365,7 @@ impl RequestConfig {
 				keys: cache_keys.clone(),
 			};
 
-			let payload = serde_json::to_vec(&message)?;
+			let payload = rivet_util::serde::json_to_vec!(&message)?;
 
 			if let Err(err) = ups
 				.publish(
@@ -495,12 +495,12 @@ impl RequestConfig {
 			keys,
 			getter,
 			|value: &Value| -> Result<Vec<u8>> {
-				serde_json::to_vec(&value)
+				rivet_util::serde::json_to_vec!(&value)
 					.map_err(Error::SerdeEncode)
 					.map_err(Into::into)
 			},
 			|value: &[u8]| -> Result<Value> {
-				serde_json::from_slice(value)
+				rivet_util::serde::json_from_slice!(value)
 					.map_err(Error::SerdeDecode)
 					.map_err(Into::into)
 			},

engine/packages/depot/Cargo.toml

@@ -30,19 +30,19 @@ rivet-error.workspace = true
 rivet-metrics.workspace = true
 rivet-pools.workspace = true
 rivet-runtime.workspace = true
+rivet-util.workspace = true
+rusqlite.workspace = true
 scc.workspace = true
-serde.workspace = true
 serde_bare.workspace = true
 serde_json.workspace = true
+serde.workspace = true
 sha2.workspace = true
-rusqlite.workspace = true
 tempfile.workspace = true
 tokio.workspace = true
 tokio-util.workspace = true
 tracing.workspace = true
 universaldb.workspace = true
 universalpubsub.workspace = true
-util.workspace = true
 uuid.workspace = true
 vbare.workspace = true
 

engine/packages/depot/src/conveyer/types/branch.rs

@@ -77,14 +77,14 @@ impl OwnedVersionedData for VersionedDatabaseBranchRecord {
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
 		match version {
-			1 => Ok(Self::Current(serde_bare::from_slice(payload)?)),
+			1 => Ok(Self::Current(rivet_util::serde::bare_from_slice!(payload)?)),
 			_ => bail!("invalid depot DatabaseBranchRecord version: {version}"),
 		}
 	}
 
 	fn serialize_version(self, _version: u16) -> Result<Vec<u8>> {
 		match self {
-			Self::Current(data) => serde_bare::to_vec(&data).map_err(Into::into),
+			Self::Current(data) => rivet_util::serde::bare_to_vec!(&data).map_err(Into::into),
 		}
 	}
 }
@@ -108,14 +108,14 @@ impl OwnedVersionedData for VersionedDatabasePointer {
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
 		match version {
-			1 => Ok(Self::V1(serde_bare::from_slice(payload)?)),
+			1 => Ok(Self::V1(rivet_util::serde::bare_from_slice!(payload)?)),
 			_ => bail!("invalid depot DatabasePointer version: {version}"),
 		}
 	}
 
 	fn serialize_version(self, _version: u16) -> Result<Vec<u8>> {
 		match self {
-			Self::V1(data) => serde_bare::to_vec(&data).map_err(Into::into),
+			Self::V1(data) => rivet_util::serde::bare_to_vec!(&data).map_err(Into::into),
 		}
 	}
 }
@@ -139,14 +139,14 @@ impl OwnedVersionedData for VersionedBucketBranchRecord {
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
 		match version {
-			1 => Ok(Self::V1(serde_bare::from_slice(payload)?)),
+			1 => Ok(Self::V1(rivet_util::serde::bare_from_slice!(payload)?)),
 			_ => bail!("invalid depot BucketBranchRecord version: {version}"),
 		}
 	}
 
 	fn serialize_version(self, _version: u16) -> Result<Vec<u8>> {
 		match self {
-			Self::V1(data) => serde_bare::to_vec(&data).map_err(Into::into),
+			Self::V1(data) => rivet_util::serde::bare_to_vec!(&data).map_err(Into::into),
 		}
 	}
 }
@@ -170,14 +170,14 @@ impl OwnedVersionedData for VersionedBucketPointer {
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
 		match version {
-			1 => Ok(Self::V1(serde_bare::from_slice(payload)?)),
+			1 => Ok(Self::V1(rivet_util::serde::bare_from_slice!(payload)?)),
 			_ => bail!("invalid depot BucketPointer version: {version}"),
 		}
 	}
 
 	fn serialize_version(self, _version: u16) -> Result<Vec<u8>> {
 		match self {
-			Self::V1(data) => serde_bare::to_vec(&data).map_err(Into::into),
+			Self::V1(data) => rivet_util::serde::bare_to_vec!(&data).map_err(Into::into),
 		}
 	}
 }
@@ -201,14 +201,14 @@ impl OwnedVersionedData for VersionedPointerSnapshot {
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
 		match version {
-			1 => Ok(Self::V1(serde_bare::from_slice(payload)?)),
+			1 => Ok(Self::V1(rivet_util::serde::bare_from_slice!(payload)?)),
 			_ => bail!("invalid depot PointerSnapshot version: {version}"),
 		}
 	}
 
 	fn serialize_version(self, _version: u16) -> Result<Vec<u8>> {
 		match self {
-			Self::V1(data) => serde_bare::to_vec(&data).map_err(Into::into),
+			Self::V1(data) => rivet_util::serde::bare_to_vec!(&data).map_err(Into::into),
 		}
 	}
 }

engine/packages/depot/src/conveyer/types/compaction.rs

@@ -61,14 +61,14 @@ macro_rules! impl_compaction_versioned_data {
 
 			fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
 				match version {
-					1 => Ok(Self::V1(serde_bare::from_slice(payload)?)),
+					1 => Ok(Self::V1(rivet_util::serde::bare_from_slice!(payload)?)),
 					_ => bail!("invalid depot {} version: {version}", $name),
 				}
 			}
 
 			fn serialize_version(self, _version: u16) -> Result<Vec<u8>> {
 				match self {
-					Self::V1(data) => serde_bare::to_vec(&data).map_err(Into::into),
+					Self::V1(data) => rivet_util::serde::bare_to_vec!(&data).map_err(Into::into),
 				}
 			}
 		}

engine/packages/depot/src/conveyer/types/history_pin.rs

@@ -43,14 +43,14 @@ impl OwnedVersionedData for VersionedDbHistoryPin {
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
 		match version {
-			1 => Ok(Self::V1(serde_bare::from_slice(payload)?)),
+			1 => Ok(Self::V1(rivet_util::serde::bare_from_slice!(payload)?)),
 			_ => bail!("invalid depot DbHistoryPin version: {version}"),
 		}
 	}
 
 	fn serialize_version(self, _version: u16) -> Result<Vec<u8>> {
 		match self {
-			Self::V1(data) => serde_bare::to_vec(&data).map_err(Into::into),
+			Self::V1(data) => rivet_util::serde::bare_to_vec!(&data).map_err(Into::into),
 		}
 	}
 }

engine/packages/depot/src/conveyer/types/policy.rs

@@ -59,14 +59,14 @@ impl OwnedVersionedData for VersionedPitrPolicy {
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
 		match version {
-			1 => Ok(Self::V1(serde_bare::from_slice(payload)?)),
+			1 => Ok(Self::V1(rivet_util::serde::bare_from_slice!(payload)?)),
 			_ => bail!("invalid depot PitrPolicy version: {version}"),
 		}
 	}
 
 	fn serialize_version(self, _version: u16) -> Result<Vec<u8>> {
 		match self {
-			Self::V1(policy) => serde_bare::to_vec(&policy).map_err(Into::into),
+			Self::V1(policy) => rivet_util::serde::bare_to_vec!(&policy).map_err(Into::into),
 		}
 	}
 }
@@ -86,14 +86,14 @@ impl OwnedVersionedData for VersionedShardCachePolicy {
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
 		match version {
-			1 => Ok(Self::V1(serde_bare::from_slice(payload)?)),
+			1 => Ok(Self::V1(rivet_util::serde::bare_from_slice!(payload)?)),
 			_ => bail!("invalid depot ShardCachePolicy version: {version}"),
 		}
 	}
 
 	fn serialize_version(self, _version: u16) -> Result<Vec<u8>> {
 		match self {
-			Self::V1(policy) => serde_bare::to_vec(&policy).map_err(Into::into),
+			Self::V1(policy) => rivet_util::serde::bare_to_vec!(&policy).map_err(Into::into),
 		}
 	}
 }

engine/packages/depot/src/conveyer/types/restore_points.rs

@@ -161,14 +161,14 @@ impl OwnedVersionedData for VersionedRestorePointRecord {
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
 		match version {
-			1 => Ok(Self::V1(serde_bare::from_slice(payload)?)),
+			1 => Ok(Self::V1(rivet_util::serde::bare_from_slice!(payload)?)),
 			_ => bail!("invalid depot RestorePointRecord version: {version}"),
 		}
 	}
 
 	fn serialize_version(self, _version: u16) -> Result<Vec<u8>> {
 		match self {
-			Self::V1(data) => serde_bare::to_vec(&data).map_err(Into::into),
+			Self::V1(data) => rivet_util::serde::bare_to_vec!(&data).map_err(Into::into),
 		}
 	}
 }

engine/packages/depot/src/conveyer/types/storage.rs

@@ -53,14 +53,14 @@ impl OwnedVersionedData for VersionedDBHead {
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
 		match version {
-			1 => Ok(Self::V1(serde_bare::from_slice(payload)?)),
+			1 => Ok(Self::V1(rivet_util::serde::bare_from_slice!(payload)?)),
 			_ => bail!("invalid depot DBHead version: {version}"),
 		}
 	}
 
 	fn serialize_version(self, _version: u16) -> Result<Vec<u8>> {
 		match self {
-			Self::V1(data) => serde_bare::to_vec(&data).map_err(Into::into),
+			Self::V1(data) => rivet_util::serde::bare_to_vec!(&data).map_err(Into::into),
 		}
 	}
 }
@@ -84,14 +84,14 @@ impl OwnedVersionedData for VersionedCommitRow {
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
 		match version {
-			1 => Ok(Self::V1(serde_bare::from_slice(payload)?)),
+			1 => Ok(Self::V1(rivet_util::serde::bare_from_slice!(payload)?)),
 			_ => bail!("invalid depot CommitRow version: {version}"),
 		}
 	}
 
 	fn serialize_version(self, _version: u16) -> Result<Vec<u8>> {
 		match self {
-			Self::V1(data) => serde_bare::to_vec(&data).map_err(Into::into),
+			Self::V1(data) => rivet_util::serde::bare_to_vec!(&data).map_err(Into::into),
 		}
 	}
 }
@@ -115,14 +115,14 @@ impl OwnedVersionedData for VersionedMetaCompact {
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
 		match version {
-			1 => Ok(Self::V1(serde_bare::from_slice(payload)?)),
+			1 => Ok(Self::V1(rivet_util::serde::bare_from_slice!(payload)?)),
 			_ => bail!("invalid depot MetaCompact version: {version}"),
 		}
 	}
 
 	fn serialize_version(self, _version: u16) -> Result<Vec<u8>> {
 		match self {
-			Self::V1(data) => serde_bare::to_vec(&data).map_err(Into::into),
+			Self::V1(data) => rivet_util::serde::bare_to_vec!(&data).map_err(Into::into),
 		}
 	}
 }

engine/packages/engine/src/commands/udb/cli.rs

@@ -929,21 +929,23 @@ impl SubCommand {
 										// A v2 entry roundtrips byte-identically through the v2
 										// schema. v3 entries either fail to deserialize as v2 or
 										// re-serialize to different bytes, so they are ignored.
-										let v2_entry: proto_v2::ChangelogEntry =
-											match serde_bare::from_slice(entry.value()) {
-												Ok(v) => v,
-												Err(_) => {
-													v3_count += 1;
-													continue;
-												}
-											};
-										let reserialized = match serde_bare::to_vec(&v2_entry) {
-											Ok(b) => b,
+										let v2_entry: proto_v2::ChangelogEntry = match rivet_util::serde::bare_from_slice!(
+											entry.value()
+										) {
+											Ok(v) => v,
 											Err(_) => {
 												v3_count += 1;
 												continue;
 											}
 										};
+										let reserialized =
+											match rivet_util::serde::bare_to_vec!(&v2_entry) {
+												Ok(b) => b,
+												Err(_) => {
+													v3_count += 1;
+													continue;
+												}
+											};
 										if reserialized != entry.value() {
 											v3_count += 1;
 											continue;

engine/packages/epoxy/src/http_client.rs

@@ -179,7 +179,8 @@ async fn send_request_to_address(
 	let client = rivet_pools::reqwest::client().await?;
 
 	// Create the request
-	let request = serde_bare::to_vec(&request).context("failed to serialize epoxy request")?;
+	let request =
+		rivet_util::serde::bare_to_vec!(&request).context("failed to serialize epoxy request")?;
 
 	// Send the request
 	let response_result = client
@@ -223,7 +224,7 @@ async fn send_request_to_address(
 	}
 
 	let body = response.bytes().await?;
-	let response_body = serde_bare::from_slice(&body)?;
+	let response_body = rivet_util::serde::bare_from_slice!(&body)?;
 
 	tracing::debug!(
 		to_replica = to_replica_id,

engine/packages/epoxy/src/http_routes.rs

@@ -91,5 +91,5 @@ async fn handle_request(ctx: ApiCtx, request: protocol::Request) -> Result<Vec<u
 	metrics::record_request_result(kind_label, result_label);
 	perf_finish!(measure, fields: { result = %result_label });
 
-	serde_bare::to_vec(&res?).map_err(Into::into)
+	rivet_util::serde::bare_to_vec!(&res?).map_err(Into::into)
 }