fix(api): fix query serialization for remote req

Cargo.toml

@@ -59,6 +59,7 @@ rstest = "0.26.1"
 rustls-pemfile = "2.2.0"
 rustyline = "15.0.0"
 serde_bare = "0.5.0"
+serde_html_form = "0.2.7"
 serde_yaml = "0.9.34"
 sha2 = "0.10"
 slog = "2.7"

docker/template/src/docker-compose.ts

@@ -320,7 +320,6 @@ export function generateDockerCompose(context: TemplateContext) {
             restart: "unless-stopped",
             environment: [
                `RIVET_ENDPOINT=http://${context.getServiceHost("rivet-engine", datacenter.name, 0)}:6420`,
-               `RUNNER_HOST=${context.getServiceHost("runner", datacenter.name, i)}`,
             ],
             stop_grace_period: "4s",
             ports: isPrimary && i === 0 ? [`5050:5050`] : undefined,

packages/common/api-builder/src/context.rs

@@ -32,8 +32,6 @@ impl fmt::Debug for ApiCtx {
 
 impl ApiCtx {
 	pub fn new(global: GlobalApiCtx, ray_id: Id, req_id: Id) -> Result<Self> {
-		// Create StandaloneCtx synchronously by using a blocking call
-		// This is necessary because we need Clone support and async Clone is not possible
 		let standalone_ctx = StandaloneCtx::new(
 			global.db.clone(),
 			global.config.clone(),

packages/common/api-builder/src/error_response.rs

@@ -54,6 +54,7 @@ impl IntoResponse for ApiError {
 			internal: if error_response.group == rivet_error::INTERNAL_ERROR.group
 				&& error_response.code == rivet_error::INTERNAL_ERROR.code
 			{
+				tracing::debug!(err=?self.0, "internal debug error");
 				Some(format!("{}", self.0).into())
 			} else {
 				None

packages/common/api-client/Cargo.toml

@@ -16,6 +16,7 @@ rivet-config.workspace = true
 rivet-error.workspace = true
 rivet-pools.workspace = true
 rivet-util.workspace = true
+serde_html_form.workspace = true
 serde.workspace = true
 tokio.workspace = true
 tracing.workspace = true

packages/common/api-client/src/lib.rs

@@ -25,20 +25,26 @@ pub async fn request_remote_datacenter_raw(
 		.ok_or_else(|| errors::Datacenter::NotFound.build())?;
 
 	let client = rivet_pools::reqwest::client().await?;
-	let url = dc.api_peer_url.join(endpoint)?;
-
-	let mut request = client.request(method, url).headers(headers);
+	let mut url = dc.api_peer_url.join(endpoint)?;
 
+	// NOTE: We don't use reqwest's `.query` because it doesn't support list query parameters
 	if let Some(q) = query {
-		request = request.query(q);
+		url.set_query(Some(&serde_html_form::to_string(q)?));
 	}
 
+	let mut request = client.request(method, url).headers(headers);
+
 	if let Some(b) = body {
 		request = request.json(b);
 	}
 
-	let res = request.send().await?;
-	rivet_api_util::reqwest_to_axum_response(res).await
+	let res = request
+		.send()
+		.await
+		.context("failed sending request to remote dc")?;
+	rivet_api_util::reqwest_to_axum_response(res)
+		.await
+		.context("failed parsing response from remote dc")
 }
 
 /// Generic function to make requests to a specific datacenter
@@ -59,20 +65,26 @@ where
 		.ok_or_else(|| errors::Datacenter::NotFound.build())?;
 
 	let client = rivet_pools::reqwest::client().await?;
-	let url = dc.api_peer_url.join(endpoint)?;
-
-	let mut request = client.request(method, url).headers(headers);
+	let mut url = dc.api_peer_url.join(endpoint)?;
 
+	// NOTE: We don't use reqwest's `.query` because it doesn't support list query parameters
 	if let Some(q) = query {
-		request = request.query(q);
+		url.set_query(Some(&serde_html_form::to_string(q)?));
 	}
 
+	let mut request = client.request(method, url).headers(headers);
+
 	if let Some(b) = body {
 		request = request.json(b);
 	}
 
-	let res = request.send().await?;
-	rivet_api_util::parse_response::<T>(res).await
+	let res = request
+		.send()
+		.await
+		.context("failed sending request to remote dc")?;
+	rivet_api_util::parse_response::<T>(res)
+		.await
+		.context("failed parsing response from remote dc")
 }
 
 /// Generic function to fanout requests to all datacenters and aggregate results

packages/common/types/src/datacenters.rs

@@ -6,5 +6,4 @@ use utoipa::ToSchema;
 pub struct Datacenter {
 	pub datacenter_label: u16,
 	pub name: String,
-	pub url: String,
 }

packages/core/api-public/src/datacenters.rs

@@ -21,7 +21,6 @@ pub async fn list(ctx: ApiCtx, _path: (), _query: ()) -> Result<ListResponse> {
 			.map(|dc| Datacenter {
 				datacenter_label: dc.datacenter_label,
 				name: dc.name.clone(),
-				url: dc.guard_url.to_string(),
 			})
 			.collect(),
 		pagination: Pagination { cursor: None },

packages/services/epoxy/src/workflows/coordinator/reconfigure.rs

@@ -153,19 +153,25 @@ pub async fn health_check_new_replicas(
 		async move {
 			tracing::info!(?replica_id, "sending health check to replica");
 
+			let from_replica_id = ctx.config().epoxy_replica_id();
 			let request = protocol::Request {
-				from_replica_id: ctx.config().epoxy_replica_id(),
+				from_replica_id,
 				to_replica_id: replica_id,
 				kind: protocol::RequestKind::HealthCheckRequest,
 			};
 
-			crate::http_client::send_message_to_address(
-				replica.api_peer_url.clone(),
-				replica_id,
-				request,
-			)
-			.await
-			.with_context(|| format!("health check failed for replica {}", replica_id))?;
+			// Call directly instead of sending request for same replica
+			if from_replica_id == replica_id {
+				tracing::info!(?replica_id, "skipping health check to self");
+			} else {
+				crate::http_client::send_message_to_address(
+					replica.api_peer_url.clone(),
+					replica_id,
+					request,
+				)
+				.await
+				.with_context(|| format!("health check failed for replica {}", replica_id))?;
+			}
 
 			tracing::info!(?replica_id, "health check successful");
 			Ok(())