fix: increase log limits (#2646)

<!-- Please make sure there is an issue that this PR is correlated to. -->

## Changes

<!-- If there are frontend changes, please include screenshots. -->

Author: MasterPtato

Cargo.toml

@@ -151,7 +151,7 @@ fn ship_logs(
 		// spike of logs does not exhaust the long rate limit.
 		//
 		// 64 logs/s
-		let mut throttle_short = throttle::Throttle::new(960, Duration::from_secs(15));
+		let mut throttle_short = throttle::Throttle::new(960 * 1024, Duration::from_secs(15));
 
 		// Reduces logs from noisy games. Set reasonable caps on how
 		// much can be logged per minute. This is here to prevent games
@@ -160,10 +160,10 @@ fn ship_logs(
 		// amounts of logging. This happens very frequently.
 		//
 		// 4 logs/s * 1024 bytes/log = 4096 bytes/lobby/s = 14.7 MB/lobby/hr = 353.8 MB/lobby/day  = 10.6 GB/lobby/month
-		let mut throttle_long = throttle::Throttle::new(1200, Duration::from_secs(300));
+		let mut throttle_long = throttle::Throttle::new(1200 * 1024, Duration::from_secs(300));
 
 		// Throttles error logs
-		let mut throttle_error = throttle::Throttle::new(1, Duration::from_secs(60));
+		let mut throttle_error = throttle::Throttle::new(1 * 1024, Duration::from_secs(60));
 
 		// How many lines have been logged as a preview, see `MAX_PREVIEW_LINES`
 		let mut preview_iine_count = 0;

packages/edge/infra/client/container-runner/src/container.rs

@@ -99,28 +99,28 @@ impl ImageDownloadHandler {
 				let mut conn = ctx.sql().await?;
 				let mut tx = conn.begin().await?;
 
-				// Get total size of images directory. Note that it doesn't matter if this doesn't
-				// match the actual fs size because it should either be exactly at or below actual fs
-				// size. Also calculating fs size manually is expensive.
-				let (cache_count, images_dir_size) = sqlx::query_as::<_, (i64, i64)>(indoc!(
-					"
-					SELECT COUNT(size), COALESCE(SUM(size), 0) FROM images_cache
-					",
-				))
-				.fetch_one(&mut *tx)
-				.await
-				.map_err(Into::<anyhow::Error>::into)?;
+				let ((cache_count, images_dir_size), image_download_size) = tokio::try_join!(
+					async {
+						// Get total size of images directory. Note that it doesn't matter if this doesn't
+						// match the actual fs size because it should either be exactly at or below actual fs
+						// size. Also calculating fs size manually is expensive.
+						sqlx::query_as::<_, (i64, i64)>(indoc!(
+							"
+							SELECT COUNT(size), COALESCE(SUM(size), 0) FROM images_cache
+							",
+						))
+						.fetch_one(&mut *tx)
+						.await
+						.map_err(Into::<anyhow::Error>::into)
+					},
+					// NOTE: The image size here is somewhat misleading because its only the size of the
+					// downloaded archive and not the total disk usage after it is unpacked. However, this is
+					// good enough
+					self.fetch_image_download_size(ctx, image_config),
+				)?;
 
 				// Prune images
-				//
-				// HACK: The artifact_size_bytes here is somewhat misleading because its only the size of the
-				// downloaded archive and not the total disk usage after it is unpacked. However, this is size
-				// is recalculated later once decompressed, so this will only ever exceed the cache
-				// size limit in edge cases by `actual size - compressed size`. In this situation,
-				// that extra difference is already reserved on the file system by the actor
-				// itself.
-				let (removed_count, removed_bytes) = if images_dir_size as u64
-					+ image_config.artifact_size_bytes
+				let (removed_count, removed_bytes) = if images_dir_size as u64 + image_download_size
 					> ctx.config().images.max_cache_size()
 				{
 					// Fetch as many images as it takes to clear up enough space for this new image.
@@ -157,7 +157,7 @@ impl ImageDownloadHandler {
 					.bind(image_config.id)
 					.bind(
 						(images_dir_size as u64)
-							.saturating_add(image_config.artifact_size_bytes)
+							.saturating_add(image_download_size)
 							.saturating_sub(ctx.config().images.max_cache_size()) as i64,
 					)
 					.fetch_all(&mut *tx)
@@ -202,7 +202,7 @@ impl ImageDownloadHandler {
 
 				metrics::IMAGE_CACHE_COUNT.set(cache_count + 1 - removed_count);
 				metrics::IMAGE_CACHE_SIZE
-					.set(images_dir_size + image_config.artifact_size_bytes as i64 - removed_bytes);
+					.set(images_dir_size + image_download_size as i64 - removed_bytes);
 
 				sqlx::query(indoc!(
 					"
@@ -230,7 +230,7 @@ impl ImageDownloadHandler {
 				metrics::IMAGE_CACHE_SIZE.set(images_dir_size + image_size as i64 - removed_bytes);
 
 				// Update state to signify download completed successfully
-				sqlx::query(indoc!(
+				let foo = sqlx::query(indoc!(
 					"
 					UPDATE images_cache
 					SET
@@ -487,4 +487,51 @@ impl ImageDownloadHandler {
 
 		Ok(addresses)
 	}
+
+	/// Attempts to fetch HEAD for the image download url and determine the image's download size.
+	async fn fetch_image_download_size(
+		&self,
+		ctx: &Ctx,
+		image_config: &protocol::Image,
+	) -> Result<u64> {
+		let addresses = self.get_image_addresses(ctx, image_config).await?;
+
+		let mut iter = addresses.into_iter();
+		while let Some(artifact_url) = iter.next() {
+			// Log the full URL we're attempting to download from
+			tracing::info!(image_id=?image_config.id, %artifact_url, "attempting to download image");
+
+			match reqwest::Client::new()
+				.head(&artifact_url)
+				.send()
+				.await
+				.and_then(|res| res.error_for_status())
+			{
+				Ok(res) => {
+					tracing::info!(image_id=?image_config.id, %artifact_url, "successfully fetched image HEAD");
+
+					// Read Content-Length header from response
+					let image_size = res
+						.headers()
+						.get(reqwest::header::CONTENT_LENGTH)
+						.context("no Content-Length header")?
+						.to_str()?
+						.parse::<u64>()
+						.context("invalid Content-Length header")?;
+
+					return Ok(image_size);
+				}
+				Err(err) => {
+					tracing::warn!(
+						image_id=?image_config.id,
+						%artifact_url,
+						%err,
+						"failed to fetch image HEAD"
+					);
+				}
+			}
+		}
+
+		bail!("artifact url could not be resolved");
+	}
 }

packages/edge/infra/client/manager/src/image_download_handler.rs

@@ -193,6 +193,7 @@ async fn run(init: Init, first: bool) -> Result<()> {
 		async { metrics_thread.await?.map_err(Into::into) },
 		ctx.run(rx),
 	)?;
+	
 
 	Ok(())
 }

packages/edge/infra/client/manager/src/main.rs

@@ -117,7 +117,8 @@ pub struct Image {
 	pub artifact_url_stub: String,
 	/// Direct S3 url to download the image from without ATS.
 	pub fallback_artifact_url: Option<String>,
-	/// Size in bytes of the artfiact.
+	/// Size in bytes of the artifact.
+	#[serde(default)]
 	pub artifact_size_bytes: u64,
 	pub kind: ImageKind,
 	pub compression: ImageCompression,