feat(pegboard): add metadata to runner configs

NathanFlurry · NathanFlurry · commit fc05219f8361 · 2025-10-09T21:56:44.000-07:00
diff --git a/packages/common/api-types/src/namespaces/runner_configs.rs b/packages/common/api-types/src/namespaces/runner_configs.rs
@@ -3,9 +3,17 @@ use std::collections::HashMap;
 use gas::prelude::*;
 use utoipa::ToSchema;
 
+#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
+pub struct RunnerConfig {
+	#[serde(flatten)]
+	pub kind: RunnerConfigKind,
+	#[serde(default, skip_serializing_if = "Option::is_none")]
+	pub metadata: Option<serde_json::Value>,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
 #[serde(rename_all = "snake_case")]
-pub enum RunnerConfig {
+pub enum RunnerConfigKind {
 	Normal {},
 	Serverless {
 		url: String,
@@ -21,17 +29,18 @@ pub enum RunnerConfig {
 
 impl Into<rivet_types::runner_configs::RunnerConfig> for RunnerConfig {
 	fn into(self) -> rivet_types::runner_configs::RunnerConfig {
-		match self {
-			RunnerConfig::Normal {} => rivet_types::runner_configs::RunnerConfig::Normal {},
-			RunnerConfig::Serverless {
+		let RunnerConfig { kind, metadata } = self;
+		let kind = match kind {
+			RunnerConfigKind::Normal {} => rivet_types::runner_configs::RunnerConfigKind::Normal {},
+			RunnerConfigKind::Serverless {
 				url,
 				headers,
 				request_lifespan,
 				slots_per_runner,
 				min_runners,
 				max_runners,
 				runners_margin,
-			} => rivet_types::runner_configs::RunnerConfig::Serverless {
+			} => rivet_types::runner_configs::RunnerConfigKind::Serverless {
 				url,
 				headers: headers.unwrap_or_default(),
 				request_lifespan,
@@ -40,6 +49,7 @@ impl Into<rivet_types::runner_configs::RunnerConfig> for RunnerConfig {
 				max_runners,
 				runners_margin: runners_margin.unwrap_or_default(),
 			},
-		}
+		};
+		rivet_types::runner_configs::RunnerConfig { kind, metadata }
 	}
 }
diff --git a/packages/common/config/src/config/mod.rs b/packages/common/config/src/config/mod.rs
@@ -167,13 +167,13 @@ impl Root {
 
 	pub fn validate_and_set_defaults(&mut self) -> Result<()> {
 		// Set default pubsub to Postgres if configured for database
-		if self.pubsub.is_none()
-			&& let Some(Database::Postgres(pg)) = &self.database
-		{
-			self.pubsub = Some(PubSub::PostgresNotify(pubsub::Postgres {
-				url: pg.url.clone(),
-				memory_optimization: true,
-			}));
+		if self.pubsub.is_none() {
+			if let Some(Database::Postgres(pg)) = &self.database {
+				self.pubsub = Some(PubSub::PostgresNotify(pubsub::Postgres {
+					url: pg.url.clone(),
+					memory_optimization: true,
+				}));
+			}
 		}
 
 		Ok(())
diff --git a/packages/common/types/src/runner_configs.rs b/packages/common/types/src/runner_configs.rs
@@ -3,9 +3,17 @@ use std::collections::HashMap;
 use gas::prelude::*;
 use utoipa::ToSchema;
 
+#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
+pub struct RunnerConfig {
+	#[serde(flatten)]
+	pub kind: RunnerConfigKind,
+	#[serde(default, skip_serializing_if = "Option::is_none")]
+	pub metadata: Option<serde_json::Value>,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
 #[serde(rename_all = "snake_case")]
-pub enum RunnerConfig {
+pub enum RunnerConfigKind {
 	Normal {},
 	Serverless {
 		url: String,
@@ -19,15 +27,74 @@ pub enum RunnerConfig {
 	},
 }
 
+impl From<RunnerConfig> for rivet_data::generated::namespace_runner_config_v2::RunnerConfig {
+	fn from(value: RunnerConfig) -> Self {
+		let RunnerConfig { kind, metadata } = value;
+		rivet_data::generated::namespace_runner_config_v2::RunnerConfig {
+			metadata: metadata.and_then(|value| serde_json::to_string(&value).ok()),
+			kind: match kind {
+				RunnerConfigKind::Normal {} => {
+					rivet_data::generated::namespace_runner_config_v2::RunnerConfigKind::Normal
+				}
+				RunnerConfigKind::Serverless {
+					url,
+					headers,
+					request_lifespan,
+					slots_per_runner,
+					min_runners,
+					max_runners,
+					runners_margin,
+				} => {
+					rivet_data::generated::namespace_runner_config_v2::RunnerConfigKind::Serverless(
+						rivet_data::generated::namespace_runner_config_v2::Serverless {
+							url,
+							headers: headers.into(),
+							request_lifespan,
+							slots_per_runner,
+							min_runners,
+							max_runners,
+							runners_margin,
+						},
+					)
+				}
+			},
+		}
+	}
+}
+
+impl From<rivet_data::generated::namespace_runner_config_v2::RunnerConfig> for RunnerConfig {
+	fn from(value: rivet_data::generated::namespace_runner_config_v2::RunnerConfig) -> Self {
+		let rivet_data::generated::namespace_runner_config_v2::RunnerConfig { metadata, kind } =
+			value;
+		RunnerConfig {
+			metadata: metadata.and_then(|raw| serde_json::from_str(&raw).ok()),
+			kind: match kind {
+				rivet_data::generated::namespace_runner_config_v2::RunnerConfigKind::Normal => {
+					RunnerConfigKind::Normal {}
+				}
+				rivet_data::generated::namespace_runner_config_v2::RunnerConfigKind::Serverless(
+					o,
+				) => RunnerConfigKind::Serverless {
+					url: o.url,
+					headers: o.headers.into(),
+					request_lifespan: o.request_lifespan,
+					slots_per_runner: o.slots_per_runner,
+					min_runners: o.min_runners,
+					max_runners: o.max_runners,
+					runners_margin: o.runners_margin,
+				},
+			},
+		}
+	}
+}
+
 impl From<RunnerConfig> for rivet_data::generated::namespace_runner_config_v1::Data {
 	fn from(value: RunnerConfig) -> Self {
-		match value {
-			RunnerConfig::Normal {} => {
-				rivet_data::generated::namespace_runner_config_v1::Data::Normal(
-					rivet_data::generated::namespace_runner_config_v1::Normal {},
-				)
+		match value.kind {
+			RunnerConfigKind::Normal { .. } => {
+				unreachable!("Normal runner configs do not have a v1 representation",)
 			}
-			RunnerConfig::Serverless {
+			RunnerConfigKind::Serverless {
 				url,
 				headers,
 				request_lifespan,
@@ -52,31 +119,28 @@ impl From<RunnerConfig> for rivet_data::generated::namespace_runner_config_v1::D
 
 impl From<rivet_data::generated::namespace_runner_config_v1::Data> for RunnerConfig {
 	fn from(value: rivet_data::generated::namespace_runner_config_v1::Data) -> Self {
-		match value {
-			rivet_data::generated::namespace_runner_config_v1::Data::Normal(_) => {
-				RunnerConfig::Normal {}
-			}
-			rivet_data::generated::namespace_runner_config_v1::Data::Serverless(o) => {
-				RunnerConfig::Serverless {
-					url: o.url,
-					headers: o.headers.into(),
-					request_lifespan: o.request_lifespan,
-					slots_per_runner: o.slots_per_runner,
-					min_runners: o.min_runners,
-					max_runners: o.max_runners,
-					runners_margin: o.runners_margin,
+		RunnerConfig {
+			metadata: None,
+			kind: match value {
+				rivet_data::generated::namespace_runner_config_v1::Data::Serverless(o) => {
+					RunnerConfigKind::Serverless {
+						url: o.url,
+						headers: o.headers.into(),
+						request_lifespan: o.request_lifespan,
+						slots_per_runner: o.slots_per_runner,
+						min_runners: o.min_runners,
+						max_runners: o.max_runners,
+						runners_margin: o.runners_margin,
+					}
 				}
-			}
+			},
 		}
 	}
 }
 
 impl RunnerConfig {
 	/// If updates to this run config affects the autoscaler.
 	pub fn affects_autoscaler(&self) -> bool {
-		match self {
-			Self::Serverless { .. } => true,
-			Self::Normal { .. } => false,
-		}
+		matches!(self.kind, RunnerConfigKind::Serverless { .. })
 	}
 }
diff --git a/packages/core/pegboard-serverless/src/lib.rs b/packages/core/pegboard-serverless/src/lib.rs
@@ -15,7 +15,7 @@ use pegboard::keys;
 use reqwest::header::{HeaderName, HeaderValue};
 use reqwest_eventsource as sse;
 use rivet_runner_protocol as protocol;
-use rivet_types::runner_configs::RunnerConfig;
+use rivet_types::runner_configs::{RunnerConfig, RunnerConfigKind};
 use tokio::{sync::oneshot, task::JoinHandle, time::Duration};
 use universaldb::options::StreamingMode;
 use universaldb::utils::IsolationLevel::*;
@@ -119,15 +119,15 @@ async fn tick(
 		let namespace = namespace.first().context("runner namespace not found")?;
 		let namespace_name = &namespace.name;
 
-		let RunnerConfig::Serverless {
+		let RunnerConfigKind::Serverless {
 			url,
 			headers,
 			request_lifespan,
 			slots_per_runner,
 			min_runners,
 			max_runners,
 			runners_margin,
-		} = &runner_config.config
+		} = &runner_config.config.kind
 		else {
 			tracing::warn!(
 				?ns_id,
diff --git a/packages/services/namespace/src/ops/runner_config/upsert.rs b/packages/services/namespace/src/ops/runner_config/upsert.rs
@@ -1,5 +1,5 @@
 use gas::prelude::*;
-use rivet_types::runner_configs::RunnerConfig;
+use rivet_types::runner_configs::{RunnerConfig, RunnerConfigKind};
 use universaldb::options::MutationType;
 
 use crate::{errors, keys, utils::runner_config_variant};
@@ -33,9 +33,9 @@ pub async fn namespace_runner_config_upsert(ctx: &OperationCtx, input: &Input) -
 				input.config.clone(),
 			)?;
 
-			match &input.config {
-				RunnerConfig::Normal {} => {}
-				RunnerConfig::Serverless {
+			match &input.config.kind {
+				RunnerConfigKind::Normal { .. } => {}
+				RunnerConfigKind::Serverless {
 					url,
 					headers,
 					slots_per_runner,
diff --git a/packages/services/namespace/src/utils.rs b/packages/services/namespace/src/utils.rs
@@ -1,10 +1,11 @@
 use rivet_types::{
-	keys::namespace::runner_config::RunnerConfigVariant, runner_configs::RunnerConfig,
+	keys::namespace::runner_config::RunnerConfigVariant,
+	runner_configs::{RunnerConfig, RunnerConfigKind},
 };
 
 pub fn runner_config_variant(runner_config: &RunnerConfig) -> RunnerConfigVariant {
-	match runner_config {
-		RunnerConfig::Normal { .. } => RunnerConfigVariant::Normal,
-		RunnerConfig::Serverless { .. } => RunnerConfigVariant::Serverless,
+	match runner_config.kind {
+		RunnerConfigKind::Normal { .. } => RunnerConfigVariant::Normal,
+		RunnerConfigKind::Serverless { .. } => RunnerConfigVariant::Serverless,
 	}
 }
diff --git a/packages/services/pegboard/src/ops/runner/find_dc_with_runner.rs b/packages/services/pegboard/src/ops/runner/find_dc_with_runner.rs
@@ -5,7 +5,7 @@ use futures_util::{FutureExt, StreamExt, TryFutureExt, stream::FuturesUnordered}
 use gas::prelude::*;
 use rivet_api_types::{runner_configs::list as runner_configs_list, runners::list as runners_list};
 use rivet_api_util::{HeaderMap, Method, request_remote_datacenter};
-use rivet_types::runner_configs::RunnerConfig;
+use rivet_types::runner_configs::{RunnerConfig, RunnerConfigKind};
 use serde::de::DeserializeOwned;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -79,8 +79,8 @@ async fn find_dc_with_runner_inner(ctx: &OperationCtx, input: &Input) -> Result<
 		})
 		.await?;
 	if let Some(runner) = res.first() {
-		match &runner.config {
-			RunnerConfig::Serverless { max_runners, .. } => {
+		match &runner.config.kind {
+			RunnerConfigKind::Serverless { max_runners, .. } => {
 				if *max_runners != 0 {
 					return Ok(Some(ctx.config().dc_label()));
 				}
@@ -143,10 +143,8 @@ async fn find_dc_with_runner_inner(ctx: &OperationCtx, input: &Input) -> Result<
 		|res| {
 			res.runner_configs
 				.iter()
-				.filter(|(_, rc)| match rc {
-					rivet_types::runner_configs::RunnerConfig::Serverless {
-						max_runners, ..
-					} => *max_runners != 0,
+				.filter(|(_, rc)| match rc.kind {
+					RunnerConfigKind::Serverless { max_runners, .. } => max_runners != 0,
 					_ => false,
 				})
 				.count() != 0
diff --git a/packages/services/pegboard/src/workflows/actor/runtime.rs b/packages/services/pegboard/src/workflows/actor/runtime.rs
@@ -6,8 +6,9 @@ use gas::prelude::*;
 use rivet_metrics::KeyValue;
 use rivet_runner_protocol as protocol;
 use rivet_types::{
-	actors::CrashPolicy, keys::namespace::runner_config::RunnerConfigVariant,
-	runner_configs::RunnerConfig,
+	actors::CrashPolicy,
+	keys::namespace::runner_config::RunnerConfigVariant,
+	runner_configs::{RunnerConfig, RunnerConfigKind},
 };
 use std::time::Instant;
 use universaldb::options::{ConflictRangeType, MutationType, StreamingMode};
@@ -145,8 +146,8 @@ async fn allocate_actor(
 		.await?;
 	let has_valid_serverless = runner_config_res
 		.first()
-		.map(|runner| match &runner.config {
-			RunnerConfig::Serverless { max_runners, .. } => *max_runners != 0,
+		.map(|runner| match &runner.config.kind {
+			RunnerConfigKind::Serverless { max_runners, .. } => *max_runners != 0,
 			_ => false,
 		})
 		.unwrap_or_default();
diff --git a/sdks/rust/data/src/versioned.rs b/sdks/rust/data/src/versioned.rs
diff --git a/sdks/schemas/data/namespace.runner_config.v2.bare b/sdks/schemas/data/namespace.runner_config.v2.bare
