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

package/packages/guard-core/src/utils.rs

@@ -0,0 +1,296 @@
+use anyhow::{Context, Result};
+use bytes::Bytes;
+use http_body_util::Full;
+use hyper::Response;
+use hyper::StatusCode;
+use hyper::header::HeaderName;
+use rivet_api_builder::{ErrorResponse, RawErrorResponse};
+use rivet_error::{INTERNAL_ERROR, RivetError};
+use rivet_util::Id;
+use std::time::{Duration, Instant};
+use tokio_tungstenite::tungstenite::protocol::{CloseFrame, frame::coding::CloseCode};
+use url::Url;
+
+use crate::proxy_service::{X_FORWARDED_FOR, X_RIVET_ERROR};
+use crate::response_body::ResponseBody;
+use crate::{request_context::RequestContext, route::RouteTarget};
+
+const X_RIVET_TARGET: HeaderName = HeaderName::from_static("x-rivet-target");
+const X_RIVET_ACTOR: HeaderName = HeaderName::from_static("x-rivet-actor");
+const X_RIVET_TOKEN: HeaderName = HeaderName::from_static("x-rivet-token");
+
+// In-flight requests counter
+pub(crate) struct InFlightCounter {
+	count: usize,
+	max: usize,
+}
+
+impl InFlightCounter {
+	pub(crate) fn new(max: usize) -> Self {
+		Self { count: 0, max }
+	}
+
+	pub(crate) fn try_acquire(&mut self) -> bool {
+		if self.count < self.max {
+			self.count += 1;
+			true
+		} else {
+			false
+		}
+	}
+
+	pub(crate) fn release(&mut self) {
+		self.count = self.count.saturating_sub(1);
+	}
+}
+
+// Rate limiter
+pub(crate) struct RateLimiter {
+	requests_remaining: u64,
+	reset_time: Instant,
+	requests_limit: u64,
+	period: Duration,
+}
+
+impl RateLimiter {
+	pub(crate) fn new(requests: u64, period_seconds: u64) -> Self {
+		Self {
+			requests_remaining: requests,
+			reset_time: Instant::now() + Duration::from_secs(period_seconds),
+			requests_limit: requests,
+			period: Duration::from_secs(period_seconds),
+		}
+	}
+
+	pub(crate) fn try_acquire(&mut self) -> bool {
+		let now = Instant::now();
+
+		// Check if we need to reset the counter
+		if now >= self.reset_time {
+			self.requests_remaining = self.requests_limit;
+			self.reset_time = now + self.period;
+		}
+
+		// Try to consume a request
+		if self.requests_remaining > 0 {
+			self.requests_remaining -= 1;
+			true
+		} else {
+			false
+		}
+	}
+}
+
+// Calculate backoff duration for a given retry attempt
+pub(crate) fn calculate_backoff(attempt: u32, initial_interval: u64) -> Duration {
+	Duration::from_millis(initial_interval * 2u64.pow(attempt - 1))
+}
+
+/// Modifies the incoming request before it is proxied.
+pub(crate) fn proxied_request_builder(
+	req_parts: &hyper::http::request::Parts,
+	req_ctx: &RequestContext,
+	target: &RouteTarget,
+) -> Result<hyper::http::request::Builder> {
+	let scheme = if target.port == 443 { "https" } else { "http" };
+
+	// Bracket raw IPv6 hosts
+	let host = if target.host.contains(':') && !target.host.starts_with('[') {
+		format!("[{}]", target.host)
+	} else {
+		target.host.clone()
+	};
+
+	// Ensure path starts with a leading slash
+	let path = if target.path.starts_with('/') {
+		target.path.clone()
+	} else {
+		format!("/{}", target.path)
+	};
+
+	let url = Url::parse(&format!("{scheme}://{host}:{}{}", target.port, path))
+		.context("invalid scheme/host/port when building URL")?;
+
+	// Build the proxied request
+	let mut builder = hyper::Request::builder()
+		.method(req_parts.method.clone())
+		.uri(url.to_string());
+
+	// Modify proxy headers
+	let headers = builder
+		.headers_mut()
+		.expect("request builder unexpectedly in error state");
+
+	headers.remove(X_RIVET_TARGET);
+	headers.remove(X_RIVET_ACTOR);
+	headers.remove(X_RIVET_TOKEN);
+
+	add_proxy_headers_with_addr(headers, &req_ctx)?;
+
+	Ok(builder)
+}
+
+pub(crate) fn add_proxy_headers_with_addr(
+	headers: &mut hyper::HeaderMap,
+	req_ctx: &RequestContext,
+) -> Result<()> {
+	// Copy headers except Host
+	for (key, value) in &req_ctx.headers {
+		if key != hyper::header::HOST {
+			headers.insert(key.clone(), value.clone());
+		}
+	}
+
+	// Add X-Forwarded-For header
+	if let Some(existing) = req_ctx.headers.get(X_FORWARDED_FOR) {
+		if let Ok(forwarded) = existing.to_str() {
+			if !forwarded.contains(&req_ctx.remote_addr.ip().to_string()) {
+				headers.insert(
+					X_FORWARDED_FOR,
+					hyper::header::HeaderValue::from_str(&format!(
+						"{}, {}",
+						forwarded,
+						req_ctx.remote_addr.ip()
+					))?,
+				);
+			}
+		}
+	} else {
+		headers.insert(
+			X_FORWARDED_FOR,
+			hyper::header::HeaderValue::from_str(&req_ctx.remote_addr.ip().to_string())?,
+		);
+	}
+
+	Ok(())
+}
+
+pub(crate) fn err_into_response(err: anyhow::Error) -> Result<Response<ResponseBody>> {
+	let (status, error_response) =
+		if let Some(rivet_err) = err.chain().find_map(|x| x.downcast_ref::<RivetError>()) {
+			let status = match (rivet_err.group(), rivet_err.code()) {
+				("api", "not_found") => StatusCode::NOT_FOUND,
+				("api", "unauthorized") => StatusCode::UNAUTHORIZED,
+				("api", "forbidden") => StatusCode::FORBIDDEN,
+				("guard", "rate_limit") => StatusCode::TOO_MANY_REQUESTS,
+				("guard", "upstream_error") => StatusCode::BAD_GATEWAY,
+				("guard", "routing_error") => StatusCode::BAD_GATEWAY,
+				("guard", "request_timeout") => StatusCode::GATEWAY_TIMEOUT,
+				("guard", "retry_attempts_exceeded") => StatusCode::BAD_GATEWAY,
+				("actor", "not_found") => StatusCode::NOT_FOUND,
+				("guard", "service_unavailable") => StatusCode::SERVICE_UNAVAILABLE,
+				("guard", "actor_ready_timeout") => StatusCode::SERVICE_UNAVAILABLE,
+				("guard", "no_route") => StatusCode::NOT_FOUND,
+				("guard", "invalid_request_body") => StatusCode::PAYLOAD_TOO_LARGE,
+				("guard", "invalid_response_body") => StatusCode::BAD_GATEWAY,
+				_ => StatusCode::BAD_REQUEST,
+			};
+
+			(status, ErrorResponse::from(rivet_err))
+		} else if let Some(raw_err) = err
+			.chain()
+			.find_map(|x| x.downcast_ref::<RawErrorResponse>())
+		{
+			(raw_err.0, raw_err.1.clone())
+		} else {
+			(
+				StatusCode::INTERNAL_SERVER_ERROR,
+				ErrorResponse::from(&RivetError {
+					schema: &rivet_error::INTERNAL_ERROR,
+					meta: None,
+					message: None,
+				}),
+			)
+		};
+
+	let body_json = serde_json::to_vec(&error_response)?;
+	let bytes = Bytes::from(body_json);
+
+	Response::builder()
+		.status(status)
+		.header(hyper::header::CONTENT_TYPE, "application/json")
+		.body(ResponseBody::Full(Full::new(bytes)))
+		.map_err(Into::into)
+}
+
+pub(crate) fn should_retry_request(res: &Result<Response<ResponseBody>>) -> bool {
+	match res {
+		Ok(resp) => should_retry_request_inner(resp.status(), resp.headers()),
+		Err(err) => {
+			if let Some(rivet_err) = err.chain().find_map(|x| x.downcast_ref::<RivetError>()) {
+				rivet_err.group() == "guard" && rivet_err.code() == "service_unavailable"
+			} else {
+				false
+			}
+		}
+	}
+}
+
+// Determine if a response should trigger a retry: 503 + x-rivet-error
+pub(crate) fn should_retry_request_inner(status: StatusCode, headers: &hyper::HeaderMap) -> bool {
+	status == StatusCode::SERVICE_UNAVAILABLE && headers.contains_key(X_RIVET_ERROR)
+}
+
+// Determine if a websocket error is retryable (e.g., transient UPS/tunnel issues)
+pub(crate) fn is_retryable_ws_error(err: &anyhow::Error) -> bool {
+	if let Some(rivet_err) = err.chain().find_map(|x| x.downcast_ref::<RivetError>()) {
+		rivet_err.group() == "guard" && rivet_err.code() == "websocket_service_unavailable"
+	} else {
+		false
+	}
+}
+
+pub fn is_ws_hibernate(err: &anyhow::Error) -> bool {
+	if let Some(rivet_err) = err.chain().find_map(|x| x.downcast_ref::<RivetError>()) {
+		rivet_err.group() == "guard" && rivet_err.code() == "websocket_service_hibernate"
+	} else {
+		false
+	}
+}
+
+pub(crate) fn err_to_close_frame(err: anyhow::Error, ray_id: Id) -> CloseFrame {
+	let rivet_err = err
+		.chain()
+		.find_map(|x| x.downcast_ref::<RivetError>())
+		.cloned()
+		.unwrap_or_else(|| RivetError::from(&INTERNAL_ERROR));
+
+	let code = match (rivet_err.group(), rivet_err.code()) {
+		("ws", "connection_closed") | ("ws", "eviction") => CloseCode::Normal,
+		_ => CloseCode::Error,
+	};
+
+	match code {
+		CloseCode::Normal => tracing::debug!("websocket closed"),
+		_ => tracing::error!(?err, "websocket failed"),
+	}
+
+	let reason = format!("{}.{}#{}", rivet_err.group(), rivet_err.code(), ray_id);
+
+	// NOTE: reason cannot be more than 123 bytes as per the WS protocol
+	let reason = rivet_util::safe_slice(&reason, 0, 123).into();
+
+	CloseFrame { code, reason }
+}
+
+pub(crate) fn to_hyper_close(frame: Option<CloseFrame>) -> hyper_tungstenite::tungstenite::Message {
+	if let Some(frame) = frame {
+		// Manual conversion to handle different tungstenite versions
+		let code_num: u16 = frame.code.into();
+		let reason = frame.reason.clone();
+
+		tokio_tungstenite::tungstenite::Message::Close(Some(
+			tokio_tungstenite::tungstenite::protocol::CloseFrame {
+				code: code_num.into(),
+				reason,
+			},
+		))
+	} else {
+		tokio_tungstenite::tungstenite::Message::Close(Some(
+			tokio_tungstenite::tungstenite::protocol::CloseFrame {
+				code: CloseCode::Normal,
+				reason: "ws.closed".into(),
+			},
+		))
+	}
+}

package/packages/guard-core/src/websocket_handle.rs

@@ -2,7 +2,7 @@ use anyhow::*;
 use futures_util::{SinkExt, StreamExt, stream::Peekable};
 use hyper::upgrade::Upgraded;
 use hyper_tungstenite::HyperWebsocket;
-use hyper_tungstenite::tungstenite::Message as WsMessage;
+use hyper_tungstenite::tungstenite::Message;
 use hyper_util::rt::TokioIo;
 use std::sync::Arc;
 use tokio::sync::Mutex;
@@ -12,7 +12,7 @@ pub type WebSocketReceiver =
 	Peekable<futures_util::stream::SplitStream<WebSocketStream<TokioIo<Upgraded>>>>;
 
 pub type WebSocketSender =
-	futures_util::stream::SplitSink<WebSocketStream<TokioIo<Upgraded>>, WsMessage>;
+	futures_util::stream::SplitSink<WebSocketStream<TokioIo<Upgraded>>, Message>;
 
 #[derive(Clone)]
 pub struct WebSocketHandle {
@@ -31,7 +31,7 @@ impl WebSocketHandle {
 		})
 	}
 
-	pub async fn send(&self, message: WsMessage) -> Result<()> {
+	pub async fn send(&self, message: Message) -> Result<()> {
 		self.ws_tx.lock().await.send(message).await?;
 		Ok(())
 	}

package/packages/guard-core/tests/common/mod.rs

@@ -579,7 +579,6 @@ pub async fn start_guard_with_middleware(
 			cache_key_fn_clone,
 			middleware_fn_clone,
 			rivet_guard_core::proxy_service::PortType::Http, // Default port type for tests
-			None,                                            // No ClickHouse inserter for tests
 		));
 
 		// Run the server until shutdown signal

package/packages/guard-core/tests/custom_serve.rs

@@ -8,6 +8,7 @@ use bytes::Bytes;
 use futures_util::{SinkExt, StreamExt};
 use http_body_util::Full;
 use hyper::{Method, Request, Response, StatusCode};
+use rivet_runner_protocol as protocol;
 use tokio_tungstenite::{connect_async, tungstenite::protocol::Message};
 
 use common::{create_test_config, init_tracing, start_guard};
@@ -15,9 +16,7 @@ use rivet_guard_core::WebSocketHandle;
 use rivet_guard_core::custom_serve::{CustomServeTrait, HibernationResult};
 use rivet_guard_core::errors::WebSocketServiceHibernate;
 use rivet_guard_core::proxy_service::{ResponseBody, RoutingFn, RoutingOutput};
-use rivet_guard_core::request_context::RequestContext;
 use tokio_tungstenite::tungstenite::protocol::frame::CloseFrame;
-use uuid::Uuid;
 
 const HIBERNATION_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(2);
 
@@ -39,7 +38,7 @@ impl CustomServeTrait for TestCustomServe {
 	async fn handle_request(
 		&self,
 		req: Request<Full<Bytes>>,
-		_request_context: &mut RequestContext,
+		_unique_request_id: protocol::RequestId,
 	) -> Result<Response<ResponseBody>> {
 		// Track this HTTP call
 		let path = req.uri().path().to_string();
@@ -70,8 +69,7 @@ impl CustomServeTrait for TestCustomServe {
 		websocket: WebSocketHandle,
 		_headers: &hyper::HeaderMap,
 		_path: &str,
-		_request_context: &mut RequestContext,
-		_unique_request_id: Uuid,
+		_unique_request_id: protocol::RequestId,
 		_after_hibernation: bool,
 	) -> Result<Option<CloseFrame>> {
 		// Track this WebSocket call
@@ -116,7 +114,7 @@ impl CustomServeTrait for TestCustomServe {
 	async fn handle_websocket_hibernation(
 		&self,
 		_websocket: WebSocketHandle,
-		_unique_request_id: Uuid,
+		_unique_request_id: protocol::RequestId,
 	) -> Result<HibernationResult> {
 		// Track this WebSocket call
 		self.tracker

package/packages/guard-core/tests/simple_websocket.rs

@@ -175,25 +175,25 @@ async fn start_websocket_server() -> SocketAddr {
 										match message_result {
 											Ok(msg) => {
 												match &msg {
-                                                    hyper_tungstenite::tungstenite::Message::Text(text) => {
-                                                        println!("Server: Received text message: {}", text);
-                                                    },
-                                                    hyper_tungstenite::tungstenite::Message::Binary(data) => {
-                                                        println!("Server: Received binary message of {} bytes", data.len());
-                                                    },
-                                                    hyper_tungstenite::tungstenite::Message::Ping(_) => {
-                                                        println!("Server: Received ping");
-                                                    },
-                                                    hyper_tungstenite::tungstenite::Message::Pong(_) => {
-                                                        println!("Server: Received pong");
-                                                    },
-                                                    hyper_tungstenite::tungstenite::Message::Close(_) => {
-                                                        println!("Server: Received close message");
-                                                    },
-                                                    _ => {
-                                                        println!("Server: Received unknown message type");
-                                                    }
-                                                }
+													hyper_tungstenite::tungstenite::Message::Text(text) => {
+														println!("Server: Received text message: {}", text);
+													}
+													hyper_tungstenite::tungstenite::Message::Binary(data) => {
+														println!("Server: Received binary message of {} bytes", data.len());
+													}
+													hyper_tungstenite::tungstenite::Message::Ping(_) => {
+														println!("Server: Received ping");
+													}
+													hyper_tungstenite::tungstenite::Message::Pong(_) => {
+														println!("Server: Received pong");
+													}
+													hyper_tungstenite::tungstenite::Message::Close(_) => {
+														println!("Server: Received close message");
+													}
+													_ => {
+														println!("Server: Received unknown message type");
+													}
+												}
 
 												println!("Server: Echoing message back");
 												match write.send(msg).await {

package/packages/guard-core/tests/streaming_response.rs

@@ -245,20 +245,15 @@ fn create_streaming_routing_fn(server_addr: SocketAddr) -> RoutingFn {
 						path: path.to_string(),
 					};
 
-					Ok(RoutingOutput::Route(RouteConfig {
+					return Ok(RoutingOutput::Route(RouteConfig {
 						targets: vec![target],
 						timeout: RoutingTimeout {
 							routing_timeout: 30, // 30 seconds for routing timeout
 						},
-					}))
-				} else {
-					use rivet_guard_core::proxy_service::StructuredResponse;
-					Ok(RoutingOutput::Response(StructuredResponse {
-						status: StatusCode::NOT_FOUND,
-						message: std::borrow::Cow::Borrowed("Not found"),
-						docs: None,
-					}))
+					}));
 				}
+
+				Err(anyhow::anyhow!("bad path"))
 			})
 		},
 	)

package/packages/metrics/Cargo.toml

@@ -10,10 +10,11 @@ anyhow.workspace = true
 console-subscriber.workspace = true
 hyper.workspace = true
 lazy_static.workspace = true
-opentelemetry = { workspace = true, features = ["metrics"] }
+opentelemetry.workspace = true
 opentelemetry-otlp.workspace = true
 opentelemetry-semantic-conventions.workspace = true
-opentelemetry_sdk = { workspace = true, features = ["metrics"] }
+opentelemetry_sdk.workspace = true
+prometheus.workspace = true
 rivet-config.workspace = true
 rivet-env.workspace = true
 tokio.workspace = true

package/packages/metrics/src/buckets.rs

@@ -1,22 +1,16 @@
 pub const BUCKETS: &[f64] = &[
-	// For otel
-	0.0, // Added
-	0.001, 0.0025,
-	// Copied from https://docs.rs/prometheus/latest/src/prometheus/histogram.rs.html#25-27
-	0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0, // Added
-	25.0, 50.0, 100.0, 250.0, 500.0,
+	0.001,
+	0.0025, // Copied from https://docs.rs/prometheus/latest/src/prometheus/histogram.rs.html#25-27
+	0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0, 25.0, 50.0, 100.0, 250.0, 500.0,
 ];
 
 pub const MICRO_BUCKETS: &[f64] = &[
-	// For otel
-	0.0, 0.0001, 0.00025, 0.0005, 0.001, 0.0025, 0.005, 0.01, 0.025, 0.05, 0.10, 0.25, 0.5, 1.0,
-	2.5, 5.0, 10.0, 25.0, 50.0,
+	0.0001, 0.00025, 0.0005, 0.001, 0.0025, 0.005, 0.01, 0.025, 0.05, 0.10, 0.25, 0.5, 1.0, 2.5,
+	5.0, 10.0, 25.0, 50.0,
 ];
 
 // Calculated based on the LogHistogram configuration in `packages/common/runtime/src/lib.rs`
 pub const TASK_POLL_BUCKETS: &[f64] = &[
-	// For otel
-	0.0,
 	0.00002,
 	0.000032768,
 	0.000065536,

package/packages/metrics/src/lib.rs

@@ -1,8 +1,11 @@
 mod providers;
 
 mod buckets;
+mod registry;
+mod server;
 
-pub use buckets::*;
-pub use opentelemetry as otel;
-pub use opentelemetry::KeyValue;
+pub use buckets::{BUCKETS, MICRO_BUCKETS, TASK_POLL_BUCKETS};
+pub use prometheus;
 pub use providers::{OtelProviderGuard, init_otel_providers, set_sampler_ratio};
+pub use registry::REGISTRY;
+pub use server::run_standalone;

package/packages/metrics/src/providers.rs

@@ -1,12 +1,11 @@
 // Based off of https://github.com/tokio-rs/tracing-opentelemetry/blob/v0.1.x/examples/opentelemetry-otlp.rs
 // Based off of https://github.com/tokio-rs/tracing-opentelemetry/blob/v0.1.x/examples/opentelemetry-otlp.rs
 
+use opentelemetry::KeyValue;
 use opentelemetry::trace::{SamplingResult, SpanKind};
-use opentelemetry::{KeyValue, global};
 use opentelemetry_otlp::WithExportConfig;
 use opentelemetry_sdk::{
 	Resource,
-	metrics::{MeterProviderBuilder, PeriodicReader, SdkMeterProvider},
 	trace::{RandomIdGenerator, Sampler, SdkTracerProvider},
 };
 use opentelemetry_semantic_conventions::{SCHEMA_URL, attribute::SERVICE_VERSION};
@@ -116,34 +115,6 @@ fn init_tracer_provider() -> SdkTracerProvider {
 		.build()
 }
 
-fn init_meter_provider() -> SdkMeterProvider {
-	let exporter = opentelemetry_otlp::MetricExporter::builder()
-		.with_tonic()
-		.with_temporality(opentelemetry_sdk::metrics::Temporality::Cumulative)
-		.with_protocol(opentelemetry_otlp::Protocol::Grpc)
-		.with_endpoint(otel_grpc_endpoint())
-		.build()
-		.unwrap();
-
-	let reader = PeriodicReader::builder(exporter)
-		.with_interval(std::time::Duration::from_secs(30))
-		.build();
-
-	// // For debugging in development
-	// let stdout_reader =
-	//     PeriodicReader::builder(opentelemetry_stdout::MetricExporter::default()).build();
-
-	let meter_provider = MeterProviderBuilder::default()
-		.with_resource(resource())
-		.with_reader(reader)
-		// .with_reader(stdout_reader)
-		.build();
-
-	global::set_meter_provider(meter_provider.clone());
-
-	meter_provider
-}
-
 /// Initialize OtelProviderGuard for opentelemetry-related termination processing.
 pub fn init_otel_providers() -> Option<OtelProviderGuard> {
 	// Check if otel is enabled
@@ -151,16 +122,9 @@ pub fn init_otel_providers() -> Option<OtelProviderGuard> {
 
 	if enable_otel {
 		let tracer_provider = init_tracer_provider();
-		let meter_provider = init_meter_provider();
 
-		Some(OtelProviderGuard {
-			tracer_provider,
-			meter_provider,
-		})
+		Some(OtelProviderGuard { tracer_provider })
 	} else {
-		// NOTE: OTEL's global::meters are no-op without
-		// a meter provider configured, so its safe to
-		// not set any meter provider
 		None
 	}
 }
@@ -168,7 +132,6 @@ pub fn init_otel_providers() -> Option<OtelProviderGuard> {
 /// Guard opentelemetry-related providers termination processing.
 pub struct OtelProviderGuard {
 	pub tracer_provider: SdkTracerProvider,
-	pub meter_provider: SdkMeterProvider,
 }
 
 impl Drop for OtelProviderGuard {
@@ -176,8 +139,5 @@ impl Drop for OtelProviderGuard {
 		if let Err(err) = self.tracer_provider.shutdown() {
 			eprintln!("{err:?}");
 		}
-		if let Err(err) = self.meter_provider.shutdown() {
-			eprintln!("{err:?}");
-		}
 	}
 }

package/packages/metrics/src/registry.rs

@@ -0,0 +1,7 @@
+use prometheus::*;
+
+lazy_static::lazy_static! {
+	pub static ref REGISTRY: Registry = Registry::new_custom(
+		Some("rivet".to_string()),
+		Some(labels! { })).unwrap();
+}

package/packages/metrics/src/server.rs

@@ -0,0 +1,57 @@
+use std::{net::SocketAddr, result::Result::Ok};
+
+use anyhow::*;
+use hyper::{
+	Body, Request, Response, Server,
+	header::CONTENT_TYPE,
+	service::{make_service_fn, service_fn},
+};
+use prometheus::{Encoder, TextEncoder};
+
+// TODO: Record extra labels
+
+#[tracing::instrument(skip_all)]
+pub async fn run_standalone(config: rivet_config::Config) -> Result<()> {
+	let host = config.metrics.host();
+	let port = config.metrics.port();
+	let addr = SocketAddr::from((host, port));
+
+	let server = match Server::try_bind(&addr) {
+		Ok(x) => x,
+		Err(err) => {
+			tracing::error!(?host, ?port, ?err, "failed to bind metrics server");
+
+			// TODO: Find cleaner way of crashing entire program
+			// Hard crash program since a server failing to bind is critical
+			std::process::exit(1);
+		}
+	};
+
+	let server = server.serve(make_service_fn(|_| async {
+		Ok::<_, hyper::Error>(service_fn(serve_req))
+	}));
+
+	tracing::info!(?host, ?port, "started metrics server");
+	server.await?;
+
+	Ok(())
+}
+
+#[tracing::instrument(level = "debug", skip_all)]
+async fn serve_req(_req: Request<Body>) -> Result<Response<Body>, hyper::Error> {
+	let encoder = TextEncoder::new();
+
+	let metric_families = crate::registry::REGISTRY.gather();
+	let mut buffer = Vec::new();
+	encoder
+		.encode(&metric_families, &mut buffer)
+		.expect("encode");
+
+	let response = Response::builder()
+		.status(200)
+		.header(CONTENT_TYPE, encoder.format_type())
+		.body(Body::from(buffer))
+		.expect("response");
+
+	Ok(response)
+}

package/packages/namespace/Cargo.toml

@@ -10,10 +10,7 @@ anyhow.workspace = true
 epoxy-protocol.workspace = true
 epoxy.workspace = true
 gas.workspace = true
-internal.workspace = true
-reqwest.workspace = true
 rivet-api-builder.workspace = true
-rivet-api-types.workspace = true
 rivet-api-util.workspace = true
 rivet-data.workspace = true
 rivet-error.workspace = true