feat(workers): report a failed worker creation separately from a failed module

crates/base/src/worker/pool.rs

@@ -408,7 +408,7 @@ impl WorkerPool {
             () = &mut wait_timeout => {
               if
                 tx
-                  .send(Err(anyhow!("worker did not respond in time")))
+                  .send(Err(anyhow!(WorkerError::WorkerCreationTimeout)))
                   .is_err()
               {
                 error!("main worker receiver dropped");

crates/base/tests/integration_tests.rs

@@ -1003,8 +1003,8 @@ async fn req_failure_case_timeout() {
     if !found_timeout {
       let buf = to_bytes(res.body_mut()).await.unwrap();
       let status_500 = res.status() == StatusCode::INTERNAL_SERVER_ERROR;
-      let valid_output =
-                buf == "{\"msg\":\"InvalidWorkerCreation: worker did not respond in time\"}";
+      let valid_output = buf
+        == "{\"msg\":\"WorkerUnavailable: worker did not respond in time\"}";
 
       found_timeout = status_500 && valid_output;
     }
@@ -1181,7 +1181,7 @@ async fn req_failure_case_wall_clock_reached_less_than_100ms() {
 
   assert!(
     buf == "{\"msg\":\"InvalidWorkerResponse: user worker failed to respond\"}"
-    || buf == "{\"msg\":\"InvalidWorkerCreation: worker did not respond in time\"}"
+    || buf == "{\"msg\":\"WorkerUnavailable: worker did not respond in time\"}"
     || buf
       == "{\"msg\":\"WorkerRequestCancelled: request has been cancelled by supervisor\"}"
   );

ext/workers/errors.rs

@@ -15,4 +15,7 @@ pub enum WorkerError {
   WorkerAlreadyRetired,
   #[error("request timed out")]
   RequestIdleTimeout,
+  /// The worker did not come up before the pool gave up waiting for it.
+  #[error("worker did not respond in time")]
+  WorkerCreationTimeout,
 }

ext/workers/lib.rs

@@ -302,17 +302,24 @@ pub async fn op_user_worker_create(
   };
 
   match result_rx.await {
+    // The pool dropped the sender, so no worker was produced and the module was
+    // never evaluated. Reported separately from a module that failed to
+    // evaluate, because only the latter is the caller's own code failing.
     Err(err) => Err(custom_error(
-      "InvalidWorkerCreation",
+      "WorkerUnavailable",
       format!(
         "{:#}",
         AnyError::from(err).context("failed to create worker")
       ),
     )),
 
-    Ok(Err(err)) => {
-      Err(custom_error("InvalidWorkerCreation", format!("{err:#}")))
-    }
+    Ok(Err(err)) => Err(match err.downcast_ref::<WorkerError>() {
+      Some(WorkerError::WorkerCreationTimeout) => {
+        custom_error("WorkerUnavailable", format!("{err:#}"))
+      }
+      // Anything else reaching here came out of evaluating the module.
+      _ => custom_error("InvalidWorkerCreation", format!("{err:#}")),
+    }),
     Ok(Ok(v)) => Ok((v.key.to_string(), v.reused)),
   }
 }
@@ -646,6 +653,12 @@ pub async fn op_user_worker_fetch_send(
             err.to_string(),
           ));
         }
+        // Raised while creating a worker, so it cannot reach a request that
+        // already has one. Listed rather than folded into a wildcard so a new
+        // variant still has to be decided here.
+        Some(err @ WorkerError::WorkerCreationTimeout) => {
+          return Err(custom_error("InvalidWorkerResponse", err.to_string()));
+        }
 
         None => {
           return Err(custom_error("InvalidWorkerResponse", err.to_string()));