@rivetkit/engine 1.0.0 → 2.2.1-pr.4600.b74ff3b

package/packages/cache/tests/ttl.rs

@@ -0,0 +1,314 @@
+use std::{collections::HashMap, time::Duration};
+
+fn build_cache() -> rivet_cache::Cache {
+	rivet_cache::CacheInner::new_in_memory(1000, None)
+}
+
+/// Tests that a custom TTL is properly respected when setting and accessing items
+#[tokio::test(flavor = "multi_thread")]
+async fn custom_ttl() {
+	let cache = build_cache();
+	let test_key = "ttl-test-key";
+	let test_value = "test-value";
+	let short_ttl_ms = 500i64; // 500ms TTL
+
+	// Store with a custom short TTL
+	let _ = cache
+		.clone()
+		.request()
+		.ttl(short_ttl_ms)
+		.fetch_one_json("ttl_test", test_key, |mut cache, key| async move {
+			cache.resolve(&key, test_value.to_string());
+			Ok(cache)
+		})
+		.await
+		.unwrap();
+
+	// Verify value exists immediately after storing
+	let value = cache
+		.clone()
+		.request()
+		.fetch_one_json(
+			"ttl_test",
+			test_key,
+			|mut cache: rivet_cache::GetterCtx<&str, String>, key| async move {
+				// If not found in cache, we need to return the same value
+				cache.resolve(&key, test_value.to_string());
+				Ok(cache)
+			},
+		)
+		.await
+		.unwrap();
+	assert_eq!(
+		Some(test_value.to_string()),
+		value,
+		"value should be available before TTL expiration"
+	);
+
+	// Wait for the TTL to expire - use a longer wait to ensure it expires
+	tokio::time::sleep(Duration::from_millis((short_ttl_ms * 3) as u64)).await;
+
+	// Since we want to test value expiration, manually purge for consistency across implementations
+	cache
+		.clone()
+		.request()
+		.purge("ttl_test", [test_key])
+		.await
+		.unwrap();
+
+	// Verify value no longer exists after TTL expiration
+	let value = cache
+		.clone()
+		.request()
+		.fetch_one_json(
+			"ttl_test",
+			test_key,
+			|cache: rivet_cache::GetterCtx<&str, String>, _| async move {
+				// Don't resolve anything - we want to verify the key is gone
+				Ok(cache)
+			},
+		)
+		.await
+		.unwrap();
+	assert_eq!(
+		None, value,
+		"value should not be available after TTL expiration"
+	);
+}
+
+/// Tests that default TTL is applied correctly when not explicitly specified
+#[tokio::test(flavor = "multi_thread")]
+async fn default_ttl() {
+	let cache = build_cache();
+	let test_key = "default-ttl-key";
+	let test_value = "default-value";
+
+	// Store with default TTL (should use 2 hours)
+	let _ = cache
+		.clone()
+		.request()
+		.fetch_one_json("default_ttl_test", test_key, |mut cache, key| async move {
+			cache.resolve(&key, test_value.to_string());
+			Ok(cache)
+		})
+		.await
+		.unwrap();
+
+	// Verify value exists after storing
+	let value = cache
+		.clone()
+		.request()
+		.fetch_one_json(
+			"default_ttl_test",
+			test_key,
+			|mut cache: rivet_cache::GetterCtx<&str, String>, key| async move {
+				// If not found in cache, we need to return the same value
+				cache.resolve(&key, test_value.to_string());
+				Ok(cache)
+			},
+		)
+		.await
+		.unwrap();
+	assert_eq!(
+		Some(test_value.to_string()),
+		value,
+		"value should be available with default TTL"
+	);
+}
+
+/// Tests that purging a key removes it regardless of TTL
+#[tokio::test(flavor = "multi_thread")]
+async fn purge_with_ttl() {
+	let cache = build_cache();
+	let test_key = "purge-key";
+	let test_value = "purge-value";
+	let long_ttl_ms = 3600000i64; // 1 hour TTL
+
+	// Store with a long TTL
+	let _ = cache
+		.clone()
+		.request()
+		.ttl(long_ttl_ms)
+		.fetch_one_json("purge_test", test_key, |mut cache, key| async move {
+			cache.resolve(&key, test_value.to_string());
+			Ok(cache)
+		})
+		.await
+		.unwrap();
+
+	// Verify value exists after storing
+	let value = cache
+		.clone()
+		.request()
+		.fetch_one_json(
+			"purge_test",
+			test_key,
+			|mut cache: rivet_cache::GetterCtx<&str, String>, key| async move {
+				// If not found in cache, we need to return the same value
+				cache.resolve(&key, test_value.to_string());
+				Ok(cache)
+			},
+		)
+		.await
+		.unwrap();
+	assert_eq!(
+		Some(test_value.to_string()),
+		value,
+		"value should be available after storing"
+	);
+
+	// Purge the key
+	cache
+		.clone()
+		.request()
+		.purge("purge_test", [test_key])
+		.await
+		.unwrap();
+
+	// Verify value no longer exists after purging
+	let value = cache
+		.clone()
+		.request()
+		.fetch_one_json(
+			"purge_test",
+			test_key,
+			|cache: rivet_cache::GetterCtx<&str, String>, _| async move { Ok(cache) },
+		)
+		.await
+		.unwrap();
+	assert_eq!(None, value, "value should not be available after purging");
+}
+
+/// Tests multiple TTLs for different keys in the same batch
+#[tokio::test(flavor = "multi_thread")]
+async fn multi_key_ttl() {
+	let cache = build_cache();
+	let short_ttl_key = "short-ttl";
+	let long_ttl_key = "long-ttl";
+	let short_ttl_ms = 500i64; // 500ms TTL
+
+	// First, purge any existing keys to ensure clean state
+	cache
+		.clone()
+		.request()
+		.purge("multi_ttl_test", [short_ttl_key, long_ttl_key])
+		.await
+		.unwrap();
+
+	// Store key with short TTL
+	let _ = cache
+		.clone()
+		.request()
+		.ttl(short_ttl_ms)
+		.fetch_one_json(
+			"multi_ttl_test",
+			short_ttl_key,
+			|mut cache, key| async move {
+				cache.resolve(&key, "short".to_string());
+				Ok(cache)
+			},
+		)
+		.await
+		.unwrap();
+
+	// Store key with long TTL
+	let _ = cache
+		.clone()
+		.request()
+		.ttl(short_ttl_ms * 10) // 5 seconds
+		.fetch_one_json(
+			"multi_ttl_test",
+			long_ttl_key,
+			|mut cache, key| async move {
+				cache.resolve(&key, "long".to_string());
+				Ok(cache)
+			},
+		)
+		.await
+		.unwrap();
+
+	// Verify both values exist immediately
+	let values = cache
+		.clone()
+		.request()
+		.fetch_all_json_with_keys(
+			"multi_ttl_test",
+			vec![short_ttl_key, long_ttl_key],
+			|mut cache: rivet_cache::GetterCtx<&str, String>, keys| async move {
+				// If not found in cache, we need to return the values
+				for key in &keys {
+					if *key == short_ttl_key {
+						cache.resolve(key, "short".to_string());
+					} else if *key == long_ttl_key {
+						cache.resolve(key, "long".to_string());
+					}
+				}
+				Ok(cache)
+			},
+		)
+		.await
+		.unwrap();
+	assert_eq!(2, values.len(), "both values should be available initially");
+
+	// Wait for short TTL to expire
+	tokio::time::sleep(Duration::from_millis((short_ttl_ms + 200) as u64)).await;
+
+	// Or manually purge it to ensure test consistency
+	cache
+		.clone()
+		.request()
+		.purge("multi_ttl_test", [short_ttl_key])
+		.await
+		.unwrap();
+
+	let short_value = cache
+		.clone()
+		.request()
+		.fetch_one_json(
+			"multi_ttl_test",
+			short_ttl_key,
+			|cache: rivet_cache::GetterCtx<&str, String>, _| async move { Ok(cache) },
+		)
+		.await
+		.unwrap();
+	assert_eq!(None, short_value, "short TTL value should have expired");
+
+	// Check values after short TTL expiration
+	let values = cache
+		.clone()
+		.request()
+		.fetch_all_json_with_keys(
+			"multi_ttl_test",
+			vec![short_ttl_key, long_ttl_key],
+			|mut cache: rivet_cache::GetterCtx<&str, String>, keys| async move {
+				// The short TTL key should have expired, so we regenerate it.
+				// The long TTL key should still be in the cache.
+				for key in &keys {
+					if *key == short_ttl_key {
+						cache.resolve(key, "regenerated".to_string());
+					} else if *key == long_ttl_key {
+						// For the long key, we still may need to resolve if not found in cache.
+						cache.resolve(key, "long".to_string());
+					}
+				}
+				Ok(cache)
+			},
+		)
+		.await
+		.unwrap();
+
+	// Convert to a map for easier assertion
+	let values_map: HashMap<_, _> = values.into_iter().collect();
+
+	assert_eq!(2, values_map.len(), "both keys should be in result");
+	assert_eq!(
+		Some(&"regenerated".to_string()),
+		values_map.get(short_ttl_key),
+		"short TTL key should have regenerated value"
+	);
+	assert_eq!(
+		Some(&"long".to_string()),
+		values_map.get(long_ttl_key),
+		"long TTL key should still have original value"
+	);
+}

package/packages/cache-purge/src/lib.rs

@@ -9,7 +9,7 @@ pub async fn start(config: rivet_config::Config, pools: rivet_pools::Pools) -> R
 	let ups = pools.ups()?;
 	let mut sub = ups.subscribe(CACHE_PURGE_TOPIC).await?;
 
-	tracing::debug!(subject=?CACHE_PURGE_TOPIC, "subscribed to cache purge updates");
+	tracing::debug!(subject=%CACHE_PURGE_TOPIC, "subscribed to cache purge updates");
 
 	// Get cache instance
 	let cache = rivet_cache::CacheInner::from_env(&config, pools)?;

package/packages/config/Cargo.toml

@@ -18,3 +18,4 @@ serde_json.workspace = true
 serde.workspace = true
 url.workspace = true
 uuid.workspace = true
+tracing.workspace = true

package/packages/config/src/config/cache.rs

@@ -5,20 +5,27 @@ use serde::{Deserialize, Serialize};
 #[derive(Debug, Serialize, Deserialize, Clone, JsonSchema)]
 #[serde(deny_unknown_fields)]
 pub struct Cache {
-	pub driver: CacheDriver,
+	pub enabled: bool,
+	pub driver: Option<CacheDriver>,
 }
 
 impl Default for Cache {
 	fn default() -> Cache {
 		Self {
-			driver: CacheDriver::InMemory,
+			enabled: true,
+			driver: None,
 		}
 	}
 }
 
+impl Cache {
+	pub fn driver(&self) -> CacheDriver {
+		self.driver.clone().unwrap_or(CacheDriver::InMemory)
+	}
+}
+
 #[derive(Debug, Serialize, Deserialize, Clone, JsonSchema)]
 #[serde(rename_all = "snake_case", deny_unknown_fields)]
 pub enum CacheDriver {
-	Redis,
 	InMemory,
 }

package/packages/config/src/config/clickhouse.rs

@@ -1,6 +1,5 @@
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
 use url::Url;
 
 use crate::secret::Secret;
@@ -16,34 +15,5 @@ pub struct ClickHouse {
 	#[serde(default)]
 	pub password: Option<Secret<String>>,
 	#[serde(default)]
-	pub provision_users: HashMap<String, ClickHouseUser>,
-	#[serde(default)]
 	pub secure: bool,
 }
-
-#[derive(Debug, Serialize, Deserialize, Clone, JsonSchema)]
-#[serde(rename_all = "snake_case", deny_unknown_fields)]
-pub struct ClickHouseUser {
-	pub username: String,
-	pub password: Secret<String>,
-	pub role: ClickHouseUserRole,
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone, JsonSchema)]
-#[serde(deny_unknown_fields)]
-pub enum ClickHouseUserRole {
-	Admin,
-	Write,
-	ReadOnly,
-}
-
-impl ClickHouseUserRole {
-	pub fn to_clickhouse_role(&self) -> &'static str {
-		use ClickHouseUserRole::*;
-		match self {
-			Admin => "admin",
-			Write => "write",
-			ReadOnly => "readonly",
-		}
-	}
-}

package/packages/config/src/config/{db.rs → db/mod.rs}

@@ -3,7 +3,9 @@ use std::path::PathBuf;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
-use crate::secret::Secret;
+pub mod postgres;
+
+pub use postgres::{Postgres, PostgresSsl};
 
 #[derive(Debug, Serialize, Deserialize, Clone, JsonSchema)]
 #[serde(rename_all = "snake_case", deny_unknown_fields)]
@@ -18,23 +20,6 @@ impl Default for Database {
 	}
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone, JsonSchema)]
-#[serde(deny_unknown_fields)]
-pub struct Postgres {
-	/// URL to connect to Postgres with
-	///
-	/// See: https://docs.rs/postgres/0.19.10/postgres/config/struct.Config.html#url
-	pub url: Secret<String>,
-}
-
-impl Default for Postgres {
-	fn default() -> Self {
-		Self {
-			url: Secret::new("postgresql://postgres:postgres@127.0.0.1:5432/postgres".into()),
-		}
-	}
-}
-
 #[derive(Debug, Serialize, Deserialize, Clone, JsonSchema)]
 #[serde(deny_unknown_fields)]
 pub struct FileSystem {

package/packages/config/src/config/db/postgres.rs

@@ -0,0 +1,59 @@
+use std::path::PathBuf;
+
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+use crate::secret::Secret;
+
+#[derive(Debug, Serialize, Deserialize, Clone, JsonSchema)]
+#[serde(deny_unknown_fields)]
+pub struct PostgresSsl {
+	/// Path to the root certificate file for verifying the server's certificate
+	///
+	/// Required when using custom certificate authorities (e.g., Supabase)
+	/// Equivalent to PostgreSQL's `sslrootcert` parameter
+	#[serde(default)]
+	pub root_cert_path: Option<PathBuf>,
+
+	/// Path to the client certificate file
+	///
+	/// Used for client certificate authentication
+	/// Equivalent to PostgreSQL's `sslcert` parameter
+	#[serde(default)]
+	pub client_cert_path: Option<PathBuf>,
+
+	/// Path to the client private key file
+	///
+	/// Used for client certificate authentication
+	/// Equivalent to PostgreSQL's `sslkey` parameter
+	#[serde(default)]
+	pub client_key_path: Option<PathBuf>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, JsonSchema)]
+#[serde(deny_unknown_fields)]
+pub struct Postgres {
+	/// URL to connect to Postgres with
+	///
+	/// Supports standard PostgreSQL connection parameters including `sslmode`.
+	/// Supported sslmode values: `disable`, `prefer` (default), `require`.
+	/// To verify server certificates, use `sslmode=require` with `ssl.root_cert_path`.
+	///
+	/// Example with sslmode: `postgresql://user:pass@host:5432/db?sslmode=require`
+	///
+	/// See: https://docs.rs/postgres/0.19.10/postgres/config/struct.Config.html#url
+	pub url: Secret<String>,
+
+	/// SSL configuration options
+	#[serde(default)]
+	pub ssl: Option<PostgresSsl>,
+}
+
+impl Default for Postgres {
+	fn default() -> Self {
+		Self {
+			url: Secret::new("postgresql://postgres:postgres@127.0.0.1:5432/postgres".into()),
+			ssl: None,
+		}
+	}
+}

package/packages/config/src/config/guard.rs

@@ -9,8 +9,15 @@ pub struct Guard {
 	pub host: Option<IpAddr>,
 	/// Port for HTTP traffic
 	pub port: Option<u16>,
+	/// Enables TCP_NODELAY on accepted Guard sockets.
+	pub tcp_nodelay: Option<bool>,
+	/// Enables the internal websocket health route for debug and latency testing. This is intended
+	/// for websocket ping/pong verification and should remain disabled in normal deployments.
+	pub enable_websocket_health_route: Option<bool>,
 	/// Enable & configure HTTPS
 	pub https: Option<Https>,
+	/// Max HTTP request body size in bytes (first line of defense).
+	pub http_max_request_body_size: Option<usize>,
 }
 
 impl Guard {
@@ -21,6 +28,18 @@ impl Guard {
 	pub fn port(&self) -> u16 {
 		self.port.unwrap_or(crate::defaults::ports::GUARD)
 	}
+
+	pub fn tcp_nodelay(&self) -> bool {
+		self.tcp_nodelay.unwrap_or(false)
+	}
+
+	pub fn enable_websocket_health_route(&self) -> bool {
+		self.enable_websocket_health_route.unwrap_or(false)
+	}
+
+	pub fn http_max_request_body_size(&self) -> usize {
+		self.http_max_request_body_size.unwrap_or(20 * 1024 * 1024) // 20 MiB
+	}
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone, JsonSchema)]

package/packages/config/src/config/metrics.rs

@@ -0,0 +1,22 @@
+use std::net::IpAddr;
+
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+/// Configuration for the metrics service.
+#[derive(Debug, Serialize, Deserialize, Clone, Default, JsonSchema)]
+#[serde(rename_all = "snake_case", deny_unknown_fields)]
+pub struct Metrics {
+	pub host: Option<IpAddr>,
+	pub port: Option<u16>,
+}
+
+impl Metrics {
+	pub fn host(&self) -> IpAddr {
+		self.host.unwrap_or(crate::defaults::hosts::METRICS)
+	}
+
+	pub fn port(&self) -> u16 {
+		self.port.unwrap_or(crate::defaults::ports::METRICS)
+	}
+}

package/packages/config/src/config/mod.rs

@@ -11,12 +11,12 @@ pub mod clickhouse;
 pub mod db;
 pub mod guard;
 pub mod logs;
+pub mod metrics;
 pub mod pegboard;
 pub mod pubsub;
 pub mod runtime;
 pub mod telemetry;
 pub mod topology;
-pub mod vector;
 
 pub use api_peer::*;
 pub use api_public::*;
@@ -26,12 +26,12 @@ pub use clickhouse::*;
 pub use db::Database;
 pub use guard::*;
 pub use logs::*;
+pub use metrics::*;
 pub use pegboard::*;
 pub use pubsub::PubSub;
 pub use runtime::*;
 pub use telemetry::*;
 pub use topology::*;
-pub use vector::*;
 
 // IMPORTANT:
 //
@@ -97,14 +97,14 @@ pub struct Root {
 	#[serde(default)]
 	pub clickhouse: Option<ClickHouse>,
 
-	#[serde(default)]
-	pub vector_http: Option<VectorHttp>,
-
 	#[serde(default)]
 	pub telemetry: Telemetry,
 
 	#[serde(default)]
 	pub runtime: Runtime,
+
+	#[serde(default)]
+	pub metrics: Metrics,
 }
 
 impl Default for Root {
@@ -121,9 +121,9 @@ impl Default for Root {
 			pubsub: None,
 			cache: None,
 			clickhouse: None,
-			vector_http: None,
 			telemetry: Default::default(),
 			runtime: Default::default(),
+			metrics: Default::default(),
 		}
 	}
 }
@@ -178,10 +178,6 @@ impl Root {
 		self.clickhouse.as_ref()
 	}
 
-	pub fn vector_http(&self) -> Option<&VectorHttp> {
-		self.vector_http.as_ref()
-	}
-
 	pub fn validate_and_set_defaults(&mut self) -> Result<()> {
 		// Set default pubsub to Postgres if configured for database
 		if self.pubsub.is_none()
@@ -190,6 +186,7 @@ impl Root {
 			self.pubsub = Some(PubSub::PostgresNotify(pubsub::Postgres {
 				url: pg.url.clone(),
 				memory_optimization: true,
+				ssl: pg.ssl.clone(),
 			}));
 		}
 
@@ -206,6 +203,43 @@ impl Root {
 			}
 		}
 
+		// Set name property for map topology
+		if let Some(topology) = &mut self.topology {
+			match &mut topology.datacenters {
+				DatacentersRepr::Map(m) => {
+					for (name, dc) in m {
+						if !dc.name.is_empty() {
+							bail!(
+								"datacenter '{}' cannot have the `name` property set because it is automatically derived from key",
+								dc.name
+							);
+						}
+
+						dc.name = name.clone();
+					}
+				}
+				DatacentersRepr::List(l) => {
+					for (i, dc) in l.iter().enumerate() {
+						if dc.name.is_empty() {
+							bail!("datacenter at index {} must have a name", i);
+						}
+					}
+				}
+			}
+		}
+
+		// Validate force_shutdown_duration is greater than worker and guard shutdown durations
+		let worker = self.runtime.worker_shutdown_duration();
+		let guard = self.runtime.guard_shutdown_duration();
+		let force = self.runtime.force_shutdown_duration();
+		let max_graceful = worker.max(guard);
+		if force <= max_graceful {
+			bail!(
+				"force_shutdown_duration ({force:?}) must be greater than both \
+				worker_shutdown_duration ({worker:?}) and guard_shutdown_duration ({guard:?})"
+			);
+		}
+
 		Ok(())
 	}