fix: improve fetch error messages

we are using the new pending-req-wait-v2 function which supercedes pending-req-wait by providing a struct with rich error details (if the send has errored).

Instead of always saying "NetworkError when attempting to fetch resource." - we now will say things such as "NetworkError: DNS timeout", "NetworkError: TLS configuration error", or "NetworkError: HTTP response status invalid"

Author: Jake Champion

integration-tests/js-compute/fixtures/app/src/fetch-errors.js

@@ -0,0 +1,38 @@
+/// <reference path="../../../../../types/index.d.ts" />
+import { pass, assertRejects } from "./assertions.js";
+import { routes } from "./routes.js";
+import { Backend } from "fastly:backend";
+import { allowDynamicBackends } from "fastly:experimental";
+
+routes.set('/fetch-errors', async () => {
+  allowDynamicBackends(true)
+  let error;
+  error = await assertRejects(async () => {
+    await fetch('http://127.0.0.1')
+  }, DOMException, "Connection refused");
+  if (error) { return error; }
+
+  error = await assertRejects(async () => {
+    await fetch('https://fastly.com/', {
+      backend: new Backend({
+        name: 'b1',
+        target: "fastly.com:8080",
+      })
+    })
+  }, DOMException, "Connection refused");
+
+  if (error) { return error; }
+  error = await assertRejects(async () => {
+    await fetch('https://fastly.com', {
+      backend: new Backend({
+        name: 'b3',
+        target: "fastly.com",
+        useSSL: true,
+        certificateHostname: 'google.com',
+      })
+    })
+  }, DOMException, "TLS certificate error");
+  if (error) { return error; }
+
+  return pass('ok')
+});

integration-tests/js-compute/fixtures/app/src/index.js

@@ -1,3 +1,4 @@
+/// <reference path="../../../../../types/index.d.ts" />
 /* eslint-env serviceworker */
 
 import { routes } from "./routes.js";
@@ -19,6 +20,7 @@ import "./dynamic-backend.js"
 import "./env.js"
 import "./fanout.js"
 import "./fastly-now.js"
+import "./fetch-errors.js"
 import "./geoip.js"
 import "./include-bytes.js"
 import "./kv-store.js"

runtime/js-compute-runtime/core/event_loop.cpp

@@ -1,8 +1,8 @@
 #include "core/event_loop.h"
 #include "builtins/native-stream-source.h"
 #include "builtins/request-response.h"
+#include "builtins/shared/dom-exception.h"
 #include "host_interface/host_api.h"
-
 #include <chrono>
 #include <list>
 #include <memory>
@@ -146,7 +146,8 @@ bool process_pending_request(JSContext *cx, JS::HandleObject request,
 
   auto res = pending.wait();
   if (auto *err = res.to_err()) {
-    JS_ReportErrorUTF8(cx, "NetworkError when attempting to fetch resource.");
+    std::string message = std::move(err->message()).value_or("when attempting to fetch resource.");
+    builtins::DOMException::raise(cx, message, "NetworkError");
     return RejectPromiseWithPendingError(cx, response_promise);
   }
 

runtime/js-compute-runtime/host_interface/component/fastly_world.c

@@ -159,6 +159,14 @@ typedef struct {
   } val;
 } fastly_world_result_tuple2_u32_fastly_compute_at_edge_http_req_response_fastly_compute_at_edge_http_req_error_t;
 
+typedef struct {
+  bool is_err;
+  union {
+    fastly_world_tuple2_u32_fastly_compute_at_edge_http_req_response_t ok;
+    fastly_compute_at_edge_http_req_send_error_detail_t err;
+  } val;
+} fastly_world_result_tuple2_u32_fastly_compute_at_edge_http_req_response_fastly_compute_at_edge_http_req_send_error_detail_t;
+
 typedef struct {
   bool is_err;
   union {
@@ -634,6 +642,9 @@ void __wasm_import_fastly_compute_at_edge_http_req_version_set(int32_t, int32_t,
 __attribute__((__import_module__("fastly:compute-at-edge/http-req"), __import_name__("send")))
 void __wasm_import_fastly_compute_at_edge_http_req_send(int32_t, int32_t, int32_t, int32_t, int32_t);
 
+__attribute__((__import_module__("fastly:compute-at-edge/http-req"), __import_name__("send-v2")))
+void __wasm_import_fastly_compute_at_edge_http_req_send_v2(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t);
+
 __attribute__((__import_module__("fastly:compute-at-edge/http-req"), __import_name__("send-async")))
 void __wasm_import_fastly_compute_at_edge_http_req_send_async(int32_t, int32_t, int32_t, int32_t, int32_t);
 
@@ -643,12 +654,21 @@ void __wasm_import_fastly_compute_at_edge_http_req_send_async_streaming(int32_t,
 __attribute__((__import_module__("fastly:compute-at-edge/http-req"), __import_name__("pending-req-poll")))
 void __wasm_import_fastly_compute_at_edge_http_req_pending_req_poll(int32_t, int32_t);
 
+__attribute__((__import_module__("fastly:compute-at-edge/http-req"), __import_name__("pending-req-poll-v2")))
+void __wasm_import_fastly_compute_at_edge_http_req_pending_req_poll_v2(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t);
+
 __attribute__((__import_module__("fastly:compute-at-edge/http-req"), __import_name__("pending-req-wait")))
 void __wasm_import_fastly_compute_at_edge_http_req_pending_req_wait(int32_t, int32_t);
 
+__attribute__((__import_module__("fastly:compute-at-edge/http-req"), __import_name__("pending-req-wait-v2")))
+void __wasm_import_fastly_compute_at_edge_http_req_pending_req_wait_v2(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t);
+
 __attribute__((__import_module__("fastly:compute-at-edge/http-req"), __import_name__("pending-req-select")))
 void __wasm_import_fastly_compute_at_edge_http_req_pending_req_select(int32_t, int32_t, int32_t);
 
+__attribute__((__import_module__("fastly:compute-at-edge/http-req"), __import_name__("pending-req-select-v2")))
+void __wasm_import_fastly_compute_at_edge_http_req_pending_req_select_v2(int32_t, int32_t, int32_t);
+
 __attribute__((__import_module__("fastly:compute-at-edge/http-req"), __import_name__("close")))
 void __wasm_import_fastly_compute_at_edge_http_req_close(int32_t, int32_t);
 
@@ -759,7 +779,6 @@ void __wasm_import_fastly_compute_at_edge_uap_parse(int32_t, int32_t, int32_t);
 
 __attribute__((__weak__, __export_name__("cabi_realloc")))
 void *cabi_realloc(void *ptr, size_t old_size, size_t align, size_t new_size) {
-  (void) old_size;
   if (new_size == 0) return (void*) align;
   void *ret = realloc(ptr, new_size);
   if (!ret) abort();
@@ -2606,6 +2625,36 @@ bool fastly_compute_at_edge_http_req_send(fastly_compute_at_edge_http_req_reques
   }
 }
 
+bool fastly_compute_at_edge_http_req_send_v2(fastly_compute_at_edge_http_req_request_handle_t h, fastly_compute_at_edge_http_req_send_error_detail_t *s, fastly_compute_at_edge_http_req_body_handle_t b, fastly_world_string_t *backend, fastly_compute_at_edge_http_req_response_t *ret, fastly_compute_at_edge_http_req_error_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[12];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_fastly_compute_at_edge_http_req_send_v2((int32_t) (h), (int32_t) (*s).tag, (*s).mask, (int32_t) ((*s).dns_error_rcode), (int32_t) ((*s).dns_error_info_code), (int32_t) ((*s).tls_alert_id), (int32_t) (b), (int32_t) (*backend).ptr, (int32_t) (*backend).len, ptr);
+  fastly_world_result_fastly_compute_at_edge_http_req_response_fastly_compute_at_edge_http_req_error_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (fastly_compute_at_edge_http_types_response_t) {
+        (uint32_t) (*((int32_t*) (ptr + 4))),
+        (uint32_t) (*((int32_t*) (ptr + 8))),
+      };
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 4)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
 bool fastly_compute_at_edge_http_req_send_async(fastly_compute_at_edge_http_req_request_handle_t h, fastly_compute_at_edge_http_req_body_handle_t b, fastly_world_string_t *backend, fastly_compute_at_edge_http_req_pending_request_handle_t *ret, fastly_compute_at_edge_http_req_error_t *err) {
   __attribute__((__aligned__(4)))
   uint8_t ret_area[8];
@@ -2703,6 +2752,49 @@ bool fastly_compute_at_edge_http_req_pending_req_poll(fastly_compute_at_edge_htt
   }
 }
 
+bool fastly_compute_at_edge_http_req_pending_req_poll_v2(fastly_compute_at_edge_http_req_pending_request_handle_t h, fastly_compute_at_edge_http_req_send_error_detail_t *s, fastly_world_option_fastly_compute_at_edge_http_req_response_t *ret, fastly_compute_at_edge_http_req_error_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[16];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_fastly_compute_at_edge_http_req_pending_req_poll_v2((int32_t) (h), (int32_t) (*s).tag, (*s).mask, (int32_t) ((*s).dns_error_rcode), (int32_t) ((*s).dns_error_info_code), (int32_t) ((*s).tls_alert_id), ptr);
+  fastly_world_result_option_fastly_compute_at_edge_http_req_response_fastly_compute_at_edge_http_req_error_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      fastly_world_option_fastly_compute_at_edge_http_req_response_t option;
+      switch ((int32_t) (*((uint8_t*) (ptr + 4)))) {
+        case 0: {
+          option.is_some = false;
+          break;
+        }
+        case 1: {
+          option.is_some = true;
+          option.val = (fastly_compute_at_edge_http_types_response_t) {
+            (uint32_t) (*((int32_t*) (ptr + 8))),
+            (uint32_t) (*((int32_t*) (ptr + 12))),
+          };
+          break;
+        }
+      }
+      
+      result.val.ok = option;
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 4)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
 bool fastly_compute_at_edge_http_req_pending_req_wait(fastly_compute_at_edge_http_req_pending_request_handle_t h, fastly_compute_at_edge_http_req_response_t *ret, fastly_compute_at_edge_http_req_error_t *err) {
   __attribute__((__aligned__(4)))
   uint8_t ret_area[12];
@@ -2733,6 +2825,36 @@ bool fastly_compute_at_edge_http_req_pending_req_wait(fastly_compute_at_edge_htt
   }
 }
 
+bool fastly_compute_at_edge_http_req_pending_req_wait_v2(fastly_compute_at_edge_http_req_pending_request_handle_t h, fastly_compute_at_edge_http_req_send_error_detail_t *s, fastly_compute_at_edge_http_req_response_t *ret, fastly_compute_at_edge_http_req_error_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[12];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_fastly_compute_at_edge_http_req_pending_req_wait_v2((int32_t) (h), (int32_t) (*s).tag, (*s).mask, (int32_t) ((*s).dns_error_rcode), (int32_t) ((*s).dns_error_info_code), (int32_t) ((*s).tls_alert_id), ptr);
+  fastly_world_result_fastly_compute_at_edge_http_req_response_fastly_compute_at_edge_http_req_error_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (fastly_compute_at_edge_http_types_response_t) {
+        (uint32_t) (*((int32_t*) (ptr + 4))),
+        (uint32_t) (*((int32_t*) (ptr + 8))),
+      };
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (int32_t) (*((uint8_t*) (ptr + 4)));
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
 bool fastly_compute_at_edge_http_req_pending_req_select(fastly_world_list_fastly_compute_at_edge_http_req_pending_request_handle_t *h, fastly_world_tuple2_u32_fastly_compute_at_edge_http_req_response_t *ret, fastly_compute_at_edge_http_req_error_t *err) {
   __attribute__((__aligned__(4)))
   uint8_t ret_area[16];
@@ -2766,6 +2888,45 @@ bool fastly_compute_at_edge_http_req_pending_req_select(fastly_world_list_fastly
   }
 }
 
+bool fastly_compute_at_edge_http_req_pending_req_select_v2(fastly_world_list_fastly_compute_at_edge_http_req_pending_request_handle_t *h, fastly_world_tuple2_u32_fastly_compute_at_edge_http_req_response_t *ret, fastly_compute_at_edge_http_req_send_error_detail_t *err) {
+  __attribute__((__aligned__(4)))
+  uint8_t ret_area[16];
+  int32_t ptr = (int32_t) &ret_area;
+  __wasm_import_fastly_compute_at_edge_http_req_pending_req_select_v2((int32_t) (*h).ptr, (int32_t) (*h).len, ptr);
+  fastly_world_result_tuple2_u32_fastly_compute_at_edge_http_req_response_fastly_compute_at_edge_http_req_send_error_detail_t result;
+  switch ((int32_t) (*((uint8_t*) (ptr + 0)))) {
+    case 0: {
+      result.is_err = false;
+      result.val.ok = (fastly_world_tuple2_u32_fastly_compute_at_edge_http_req_response_t) {
+        (uint32_t) (*((int32_t*) (ptr + 4))),
+        (fastly_compute_at_edge_http_types_response_t) {
+          (uint32_t) (*((int32_t*) (ptr + 8))),
+          (uint32_t) (*((int32_t*) (ptr + 12))),
+        },
+      };
+      break;
+    }
+    case 1: {
+      result.is_err = true;
+      result.val.err = (fastly_compute_at_edge_http_types_send_error_detail_t) {
+        (int32_t) (*((uint8_t*) (ptr + 4))),
+        (int32_t) (*((uint8_t*) (ptr + 5))),
+        (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 6)))),
+        (uint16_t) ((int32_t) (*((uint16_t*) (ptr + 8)))),
+        (uint8_t) ((int32_t) (*((uint8_t*) (ptr + 10)))),
+      };
+      break;
+    }
+  }
+  if (!result.is_err) {
+    *ret = result.val.ok;
+    return 1;
+  } else {
+    *err = result.val.err;
+    return 0;
+  }
+}
+
 bool fastly_compute_at_edge_http_req_close(fastly_compute_at_edge_http_req_request_handle_t h, fastly_compute_at_edge_http_req_error_t *err) {
   __attribute__((__aligned__(1)))
   uint8_t ret_area[2];