Increase max args + return sizes (#35626)

GitOrigin-RevId: c88e9c84e4322617b98a2784d87e11e5e500951c

Author: jordanhunt22

crates/common/src/knobs.rs

@@ -225,12 +225,12 @@ pub static MAX_TRANSACTION_WINDOW: LazyLock<Duration> =
 
 /// Maximum size in bytes of arguments to a function.
 pub static FUNCTION_MAX_ARGS_SIZE: LazyLock<usize> = LazyLock::new(|| {
-    env_config("FUNCTION_MAX_ARGS_SIZE", 1 << 23) // 8 MiB
+    env_config("FUNCTION_MAX_ARGS_SIZE", 1 << 24) // 16 MiB
 });
 
 /// Maximum size in bytes of the result of a function.
 pub static FUNCTION_MAX_RESULT_SIZE: LazyLock<usize> = LazyLock::new(|| {
-    env_config("FUNCTION_MAX_RESULT_SIZE", 1 << 23) // 8 MiB
+    env_config("FUNCTION_MAX_RESULT_SIZE", 1 << 24) // 16 MiB
 });
 
 /// When a function exceeds FUNCTION_LIMIT_WARNING_RATIO * a corresponding
@@ -266,8 +266,8 @@ pub static TRANSACTION_MAX_SCHEDULED_TOTAL_ARGUMENT_SIZE_BYTES: LazyLock<usize>
     LazyLock::new(|| {
         env_config(
             "TRANSACTION_MAX_SCHEDULED_TOTAL_ARGUMENT_SIZE_BYTES",
-            1 << 23,
-        ) // 8 MiB
+            1 << 24,
+        ) // 16 MiB
     });
 
 /// Number of scheduled jobs that can execute in parallel.

crates/isolate/src/tests/adversarial.rs

@@ -504,56 +504,56 @@ async fn test_writes_many(rt: TestRuntime) -> anyhow::Result<()> {
 #[convex_macro::test_runtime]
 async fn test_query_args_too_big(rt: TestRuntime) -> anyhow::Result<()> {
     let t = UdfTest::default(rt).await?;
-    let data: ConvexValue = ConvexValue::Bytes(ConvexBytes::try_from(vec![0; 9_000_000])?);
+    let data: ConvexValue = ConvexValue::Bytes(ConvexBytes::try_from(vec![0; 17_000_000])?);
     let e = t
         .query_js_error("basic:readTime", assert_obj!("data" => data))
         .await?;
     assert_contains(
         &e,
-        "Arguments for basic.js:readTime are too large (actual: 8.58 MiB, limit: 8 MiB)",
+        "Arguments for basic.js:readTime are too large (actual: 16.21 MiB, limit: 16 MiB)",
     );
     Ok(())
 }
 
 #[convex_macro::test_runtime]
 async fn test_mutation_args_too_big(rt: TestRuntime) -> anyhow::Result<()> {
     let t = UdfTest::default(rt).await?;
-    let data: ConvexValue = ConvexValue::Bytes(ConvexBytes::try_from(vec![0; 9_000_000])?);
+    let data: ConvexValue = ConvexValue::Bytes(ConvexBytes::try_from(vec![0; 17_000_000])?);
     let e = t
         .mutation_js_error("basic:simpleMutation", assert_obj!("data" => data))
         .await?;
     assert_contains(
         &e,
-        "Arguments for basic.js:simpleMutation are too large (actual: 8.58 MiB, limit: 8 MiB)",
+        "Arguments for basic.js:simpleMutation are too large (actual: 16.21 MiB, limit: 16 MiB)",
     );
     Ok(())
 }
 
 #[convex_macro::test_runtime]
 async fn test_action_args_too_big(rt: TestRuntime) -> anyhow::Result<()> {
     let t = UdfTest::default(rt).await?;
-    let data: ConvexValue = ConvexValue::Bytes(ConvexBytes::try_from(vec![0; 9_000_000])?);
+    let data: ConvexValue = ConvexValue::Bytes(ConvexBytes::try_from(vec![0; 17_000_000])?);
     let e = t
         .action_js_error("basic:simpleAction", assert_obj!("data" => data))
         .await?;
     assert_contains(
         &e,
-        "Arguments for basic.js:simpleAction are too large (actual: 8.58 MiB, limit: 8 MiB)",
+        "Arguments for basic.js:simpleAction are too large (actual: 16.21 MiB, limit: 16 MiB)",
     );
     Ok(())
 }
 
 #[convex_macro::test_runtime]
 async fn test_query_args_big(rt: TestRuntime) -> anyhow::Result<()> {
     let t = UdfTest::default(rt).await?;
-    let data: ConvexValue = ConvexValue::Bytes(ConvexBytes::try_from(vec![0; 8_000_000])?);
+    let data: ConvexValue = ConvexValue::Bytes(ConvexBytes::try_from(vec![0; 16_000_000])?);
     let mut log_lines = t
         .query_log_lines("basic:readTime", assert_obj!("data" => data))
         .await?;
     let last_line = log_lines.pop().unwrap().to_pretty_string_test_only();
     assert_contains(
         &last_line,
-        "[WARN] Large size of the function arguments (actual: 8000011 bytes, limit: 8388608 \
+        "[WARN] Large size of the function arguments (actual: 16000011 bytes, limit: 16777216 \
          bytes).",
     );
     Ok(())
@@ -562,14 +562,14 @@ async fn test_query_args_big(rt: TestRuntime) -> anyhow::Result<()> {
 #[convex_macro::test_runtime]
 async fn test_mutation_args_big(rt: TestRuntime) -> anyhow::Result<()> {
     let t = UdfTest::default(rt).await?;
-    let data: ConvexValue = ConvexValue::Bytes(ConvexBytes::try_from(vec![0; 8_000_000])?);
+    let data: ConvexValue = ConvexValue::Bytes(ConvexBytes::try_from(vec![0; 16_000_000])?);
     let mut log_lines = t
         .mutation_log_lines("basic:simpleMutation", assert_obj!("data" => data))
         .await?;
     let last_line = log_lines.pop().unwrap().to_pretty_string_test_only();
     assert_contains(
         &last_line,
-        "[WARN] Large size of the function arguments (actual: 8000011 bytes, limit: 8388608 \
+        "[WARN] Large size of the function arguments (actual: 16000011 bytes, limit: 16777216 \
          bytes).",
     );
     Ok(())
@@ -578,14 +578,15 @@ async fn test_mutation_args_big(rt: TestRuntime) -> anyhow::Result<()> {
 #[convex_macro::test_runtime]
 async fn test_action_args_big(rt: TestRuntime) -> anyhow::Result<()> {
     let t = UdfTest::default(rt).await?;
-    let data: ConvexValue = ConvexValue::Bytes(ConvexBytes::try_from(vec![0; 8_000_000])?);
+    let data: ConvexValue = ConvexValue::Bytes(ConvexBytes::try_from(vec![0; 16_000_000])?);
     let mut log_lines = t
         .action_log_lines("basic:simpleAction", assert_obj!("data" => data))
         .await?;
     let last_line = log_lines.pop().unwrap().to_pretty_string_test_only();
     assert_contains(
         &last_line,
-        "[WARN] Large size of the action arguments (actual: 8000011 bytes, limit: 8388608 bytes).",
+        "[WARN] Large size of the action arguments (actual: 16000011 bytes, limit: 16777216 \
+         bytes).",
     );
     Ok(())
 }
@@ -596,13 +597,13 @@ async fn test_query_result_too_big(rt: TestRuntime) -> anyhow::Result<()> {
     let e = t
         .query_js_error(
             "adversarial:queryResultSized",
-            assert_obj!("size" => 9_000_000.0),
+            assert_obj!("size" => 17_000_000.0),
         )
         .await?;
     assert_contains(
         &e,
-        "Function adversarial.js:queryResultSized return value is too large (actual: 8.58 MiB, \
-         limit: 8 MiB)",
+        "Function adversarial.js:queryResultSized return value is too large (actual: 16.21 MiB, \
+         limit: 16 MiB)",
     );
     Ok(())
 }
@@ -613,13 +614,13 @@ async fn test_mutation_result_too_big(rt: TestRuntime) -> anyhow::Result<()> {
     let e = t
         .mutation_js_error(
             "adversarial:mutationResultSized",
-            assert_obj!("size" => 9_000_000.0),
+            assert_obj!("size" => 17_000_000.0),
         )
         .await?;
     assert_contains(
         &e,
-        "Function adversarial.js:mutationResultSized return value is too large (actual: 8.58 MiB, \
-         limit: 8 MiB)",
+        "Function adversarial.js:mutationResultSized return value is too large (actual: 16.21 \
+         MiB, limit: 16 MiB)",
     );
     Ok(())
 }
@@ -630,13 +631,13 @@ async fn test_action_result_too_big(rt: TestRuntime) -> anyhow::Result<()> {
     let e = t
         .action_js_error(
             "adversarial:actionResultSized",
-            assert_obj!("size" => 9_000_000.0),
+            assert_obj!("size" => 17_000_000.0),
         )
         .await?;
     assert_contains(
         &e,
-        "Function adversarial.js:actionResultSized return value is too large (actual: 8.58 MiB, \
-         limit: 8 MiB)",
+        "Function adversarial.js:actionResultSized return value is too large (actual: 16.21 MiB, \
+         limit: 16 MiB)",
     );
     Ok(())
 }
@@ -647,13 +648,13 @@ async fn test_query_result_big(rt: TestRuntime) -> anyhow::Result<()> {
     let mut log_lines = t
         .query_log_lines(
             "adversarial:queryResultSized",
-            assert_obj!("size" => 8_000_000.0),
+            assert_obj!("size" => 16_000_000.0),
         )
         .await?;
     let last_line = log_lines.pop().unwrap().to_pretty_string_test_only();
     assert_contains(
         &last_line,
-        "[WARN] Large size of the function return value (actual: 8000002 bytes, limit: 8388608 \
+        "[WARN] Large size of the function return value (actual: 16000002 bytes, limit: 16777216 \
          bytes).",
     );
     Ok(())
@@ -665,13 +666,13 @@ async fn test_mutation_result_big(rt: TestRuntime) -> anyhow::Result<()> {
     let mut log_lines = t
         .mutation_log_lines(
             "adversarial:mutationResultSized",
-            assert_obj!("size" => 8_000_000.0),
+            assert_obj!("size" => 16_000_000.0),
         )
         .await?;
     let last_line = log_lines.pop().unwrap().to_pretty_string_test_only();
     assert_contains(
         &last_line,
-        "[WARN] Large size of the function return value (actual: 8000002 bytes, limit: 8388608 \
+        "[WARN] Large size of the function return value (actual: 16000002 bytes, limit: 16777216 \
          bytes).",
     );
     Ok(())
@@ -683,13 +684,13 @@ async fn test_action_result_big(rt: TestRuntime) -> anyhow::Result<()> {
     let mut log_lines = t
         .action_log_lines(
             "adversarial:actionResultSized",
-            assert_obj!("size" => 8_000_000.0),
+            assert_obj!("size" => 16_000_000.0),
         )
         .await?;
     let last_line = log_lines.pop().unwrap().to_pretty_string_test_only();
     assert_contains(
         &last_line,
-        "[WARN] Large size of the action return value (actual: 8000002 bytes, limit: 8388608 \
+        "[WARN] Large size of the action return value (actual: 16000002 bytes, limit: 16777216 \
          bytes).",
     );
     Ok(())

crates/isolate/src/tests/scheduler.rs

@@ -262,9 +262,9 @@ async fn test_schedule_arguments_too_large(rt: TestRuntime) -> anyhow::Result<()
         )
         .await?;
 
-        // Scheduling a hundred functions with 100KB arguments should not.
+        // Scheduling a hundred functions with 200KB arguments should not.
         let bytes_100k = {
-            let mut bytes = [0u8; 100 * 1024];
+            let mut bytes = [0u8; 2 * 100 * 1024];
             rng.fill_bytes(&mut bytes);
             bytes.to_vec()
         };
@@ -290,16 +290,16 @@ async fn test_schedule_arguments_too_large(rt: TestRuntime) -> anyhow::Result<()
 async fn test_schedule_arguments_large(rt: TestRuntime) -> anyhow::Result<()> {
     UdfTest::run_test_with_isolate2(rt, async move |t: UdfTestType| {
         let mut rng = t.rt.rng();
-        let bytes_1m = {
-            let mut bytes = [0u8; 1000 * 1024];
+        let bytes_2m = {
+            let mut bytes = [0u8; 2 * 1000 * 1024];
             rng.fill_bytes(&mut bytes);
             bytes.to_vec()
         };
         let mut log_lines = t
             .mutation_log_lines(
                 "scheduler:scheduleMany",
                 assert_obj!("limit" => 7, "obj" => {
-                    "bytes" => ConvexValue::Bytes(bytes_1m.try_into()?)
+                    "bytes" => ConvexValue::Bytes(bytes_2m.try_into()?)
                 }),
             )
             .await?;