🐛 [RUM-16985] Stabilize WASM error metadata

Author: ImaneLargou

packages/browser-core/src/domain/wasmModules/wasmModuleTracking.spec.ts

@@ -74,6 +74,38 @@ describe('startWasmModuleTracking', () => {
     expect(getLoadedWasmModules()).toEqual([{ url: '<wasm-compile-bytes>', build_id: '' }])
   })
 
+  it('waits for module metadata before resolving streaming instantiation', async () => {
+    const wasmModule = new Uint8Array([
+      0, 97, 115, 109, 1, 0, 0, 0, 0, 11, 8, 98, 117, 105, 108, 100, 95, 105, 100, 0xab, 0xcd,
+    ])
+    let resolveArrayBuffer!: (buffer: ArrayBuffer) => void
+    const arrayBufferPromise = new Promise<ArrayBuffer>((resolve) => {
+      resolveArrayBuffer = resolve
+    })
+    const response = {
+      url: 'https://example.com/module.wasm',
+      clone: () => ({ arrayBuffer: () => arrayBufferPromise }),
+    } as Response
+    const instantiateStreamingSpy = spyOn(WebAssembly, 'instantiateStreaming').and.resolveTo(
+      {} as WebAssembly.WebAssemblyInstantiatedSource
+    )
+
+    startWasmModuleTracking()
+    let isResolved = false
+    const instantiatePromise = WebAssembly.instantiateStreaming(response).then(() => {
+      isResolved = true
+    })
+    await new Promise((resolve) => setTimeout(resolve))
+
+    expect(instantiateStreamingSpy).toHaveBeenCalled()
+    expect(isResolved).toBe(false)
+
+    resolveArrayBuffer(wasmModule.buffer)
+    await instantiatePromise
+
+    expect(getLoadedWasmModules()).toEqual([{ url: response.url, build_id: 'abcd' }])
+  })
+
   it('keeps hooks installed until every tracking client stops', () => {
     const originalCompile = WebAssembly.compile
     const stopFirstClient = startWasmModuleTracking()

packages/browser-core/src/domain/wasmModules/wasmModuleTracking.ts

@@ -57,19 +57,24 @@ function recordModuleFromView(url: string, view: ArrayBufferView): void {
   recordModule(url, view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength))
 }
 
-// Extracts build_id from a Response without consuming it for the caller.
-// Returns the original response so the actual instantiation can proceed
-// without delay; build_id extraction races in parallel.
-function captureFromResponseAsync(response: Response): Response {
+// Extracts build_id from a Response clone without consuming it for the caller.
+// Streaming compilation and metadata extraction happen in parallel, but the
+// wrapper only resolves once both are done. This guarantees that an error
+// thrown immediately by an exported function can reference the loaded module.
+function captureFromResponse(response: Response): Promise<void> {
   const url = response.url || '<wasm-instantiate-streaming-no-url>'
-  if (!registry.has(url)) {
-    response
+  if (registry.has(url)) {
+    return Promise.resolve()
+  }
+  try {
+    return response
       .clone()
       .arrayBuffer()
-      .then((buf) => recordModule(url, buf))
+      .then((buffer) => recordModule(url, buffer))
       .catch(() => undefined)
+  } catch {
+    return Promise.resolve()
   }
-  return response
 }
 
 export function startWasmModuleTracking(): () => void {
@@ -139,25 +144,19 @@ function installWasmModuleTracking(): () => void {
   if (origInstantiateStreaming) {
     WebAssembly.instantiateStreaming = function (source, importObject) {
       return Promise.resolve(source).then((response: Response) => {
-        try {
-          captureFromResponseAsync(response)
-        } catch {
-          // never block instantiation on capture failure
-        }
-        return origInstantiateStreaming.call(this, response, importObject)
+        const capturePromise = captureFromResponse(response)
+        return Promise.all([origInstantiateStreaming.call(this, response, importObject), capturePromise]).then(
+          ([result]) => result
+        )
       })
     }
   }
 
   if (origCompileStreaming) {
     WebAssembly.compileStreaming = function (source) {
       return Promise.resolve(source).then((response: Response) => {
-        try {
-          captureFromResponseAsync(response)
-        } catch {
-          // never block compilation on capture failure
-        }
-        return origCompileStreaming.call(this, response)
+        const capturePromise = captureFromResponse(response)
+        return Promise.all([origCompileStreaming.call(this, response), capturePromise]).then(([module]) => module)
       })
     }
   }

packages/browser-logs/src/domain/createErrorFieldFromRawError.spec.ts

@@ -61,7 +61,6 @@ describe('createErrorFieldFromRawError', () => {
       ],
       fingerprint: 'corge',
       handling: ErrorHandling.HANDLED,
-      source_type: 'browser',
     })
   })
 

packages/browser-logs/src/domain/createErrorFieldFromRawError.ts

@@ -21,7 +21,6 @@ export function createErrorFieldFromRawError(
     causes: rawError.causes,
     fingerprint: rawError.fingerprint,
     handling: rawError.handling,
-    source_type: isWasm ? 'browser+wasm' : 'browser',
-    ...(isWasm ? { wasm_modules: getLoadedWasmModules() } : {}),
+    ...(isWasm ? { source_type: 'browser+wasm' as const, wasm_modules: getLoadedWasmModules() } : {}),
   }
 }

packages/browser-logs/src/domain/runtimeError/runtimeErrorCollection.spec.ts

@@ -70,7 +70,6 @@ describe('runtime error collection', () => {
         handling: ErrorHandling.UNHANDLED,
         fingerprint: undefined,
         message: undefined,
-        source_type: 'browser',
       },
       message: 'error!',
       status: StatusType.error,
@@ -125,7 +124,6 @@ describe('runtime error collection', () => {
         ],
         fingerprint: undefined,
         message: undefined,
-        source_type: 'browser',
       },
       message: 'High level error',
       status: StatusType.error,