Merge pull request #425 from handsontable/fix/tier1-mount-transport-failure

fix(runner): stop filing the mount's transport failure as a Tier-1 compile error (DEV-3370)

Author: demtario

runner/apps/authoring/src/App.tsx

@@ -313,6 +313,7 @@ function reportRuntimeError(e: unknown, engine: string, framework: string): void
       causeMessage: e instanceof Error && e.cause instanceof Error ? e.cause.message : null,
       replay: e instanceof Error && (e as { replay?: boolean }).replay === true,
       online: navigator.onLine,
+      opaqueNetworkFailure: isOpaqueNetworkFailure(e),
       // Widened to the local leg (`dev:full`); the Sentry gate below stays keyed on `monitorDemos`.
       monitorDemos: previewMonitoring,
     });

runner/apps/authoring/src/tier1Report.ts

@@ -40,6 +40,9 @@ export interface Tier1ErrorFacts {
   /** `navigator.onLine`. `false` is proof the visitor's network is down, so the failure is
    *  not ours; `true` proves nothing, so it is not treated as evidence either way. */
   online?: boolean;
+  /** `isOpaqueNetworkFailure(e)`: the browser's own transport failure, e.g. the mount's
+   *  `TypeError: Failed to fetch` when the bundler cannot be reached. */
+  opaqueNetworkFailure?: boolean;
   /** The DEV-2527 demo-monitoring flag. Deliberately an input, so the gate ORDER is tested. */
   monitorDemos: boolean;
 }
@@ -66,7 +69,7 @@ const COMPILE_TITLE = "Tier-1 compile failed";
 /**
  * Decide how a Tier-1 error is reported, or that it is not.
  *
- * Order is load-bearing twice.
+ * Order is load-bearing three times.
  *
  * The compiler-asset branch comes **first, ahead of the `monitorDemos` gate**. That flag is
  * DEV-2527's temporary demo instrumentation and has a documented teardown
@@ -79,6 +82,10 @@ const COMPILE_TITLE = "Tier-1 compile failed";
  * The evaluated-throw stand-down (DEV-2552) comes next: a throw from a module that already
  * started evaluating belongs to the in-preview reporter, which files it with the preview's
  * own stack, tier, framework and demo id. Reporting it here as well filed one fault twice.
+ *
+ * The opaque transport failure (the mount's `TypeError: Failed to fetch`) stands down third,
+ * after both of those and before the `monitorDemos` gate: it is not a diagnostic about the
+ * visitor's code, and `sandpack.bundler_unreachable` already counts it.
  */
 export function tier1Report(facts: Tier1ErrorFacts): Tier1Report | null {
   if (facts.compilerUnavailable) {
@@ -109,6 +116,9 @@ export function tier1Report(facts: Tier1ErrorFacts): Tier1Report | null {
     };
   }
   if (facts.name === "SandpackEvaluationError") return null;
+  // The bundler never loaded on the visitor's network: nothing about their source, and
+  // `sandpack.bundler_unreachable` already counts it.
+  if (facts.opaqueNetworkFailure) return null;
   if (!facts.monitorDemos) return null;
   return {
     tags: { surface: "demo-runtime", kind: "sandpack-compile", tier: "1" },

runner/pipeline/tier1-report.test.mjs

@@ -1,6 +1,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { tier1Report } from "../apps/authoring/src/tier1Report.ts";
+import { isOpaqueNetworkFailure } from "../apps/authoring/src/fetchFailure.ts";
 
 // DEV-2569 / Sentry DEMOS-15. One issue held two populations — our own compiler chunk
 // failing to load, and bundler diagnostics over the visitor's half-typed source — and the
@@ -118,6 +119,40 @@ test("a compiler failure whose cause named no URL still reports", () => {
   assert.deepEqual(r.fingerprint, ["tier1-compiler-asset"]);
 });
 
+// A transport failure is not a diagnostic about the visitor's code, and `sandpack.bundler_unreachable` already counts it.
+test("the mount's opaque transport failure is not a compile error report", () => {
+  assert.equal(
+    tier1Report(compile({ name: "TypeError", message: "Failed to fetch", opaqueNetworkFailure: true })),
+    null,
+  );
+});
+
+// Mirrors the App.tsx call site: `opaqueNetworkFailure: isOpaqueNetworkFailure(e)`.
+const factsFor = (e) => compile({
+  name: e.name,
+  message: e.message,
+  opaqueNetworkFailure: isOpaqueNetworkFailure(e),
+});
+
+test("a real `TypeError: Failed to fetch` runs through the classifier and is not reported", () => {
+  assert.equal(tier1Report(factsFor(new TypeError("Failed to fetch"))), null);
+});
+
+test("a real compile error runs through the classifier and is still reported", () => {
+  const err = new Error(CODE_FRAME);
+  err.name = "SandpackCompileError";
+  assert.ok(tier1Report(factsFor(err)));
+});
+
+test("a visitor compile error is still reported when the transport flag is false or absent", () => {
+  assert.ok(tier1Report(compile({ opaqueNetworkFailure: false })));
+  assert.ok(tier1Report(compile()));
+});
+
+test("the transport stand-down does not cover the compiler-asset branch", () => {
+  assert.ok(tier1Report(compilerAsset({ opaqueNetworkFailure: true })));
+});
+
 test("every tag value is a non-empty string", () => {
   for (const facts of [compile(), compilerAsset()]) {
     const r = tier1Report(facts);