Store original encoded data along with decoding errors if body decoding fails

Author: pimterry

src/model/http/exchange.ts

@@ -127,6 +127,9 @@ export class HttpBody implements MessageBody {
 
     private _decoded: Buffer | undefined;
 
+    @observable
+    decodingError: Error | undefined;
+
     decodedPromise: ObservablePromise<Buffer | undefined> = lazyObservablePromise(async () => {
         // Exactly one of _encoded & _decoded is a buffer, never neither/both.
         if (this._decoded) return this._decoded;
@@ -140,8 +143,17 @@ export class HttpBody implements MessageBody {
             const { decoded, encoded } = await decodeBody(encodedBuffer, this._contentEncoding);
             this._encoded = encoded;
             return decoded;
-        } catch (e) {
+        } catch (e: any) {
             reportError(e);
+
+            // In most cases, we get the encoded data back regardless, so recapture it here:
+            if (e.inputBuffer) {
+                this._encoded = e.inputBuffer;
+            }
+            runInAction(() => {
+                this.decodingError = e;
+            });
+
             return undefined;
         }
     });
@@ -160,6 +172,7 @@ export class HttpBody implements MessageBody {
         // Set to a valid state for an un-decoded but totally empty body.
         this._decoded = undefined;
         this._encoded = emptyBuffer;
+        this.decodingError = undefined;
         this.decodedPromise = observablePromise(Promise.resolve(emptyBuffer));
     }
 }

src/services/ui-worker-api.ts

@@ -78,16 +78,25 @@ export async function decodeBody(encodedBuffer: Buffer, encodings: string[]) {
         return { encoded: encodedBuffer, decoded: encodedBuffer };
     }
 
-    const result = await callApi<DecodeRequest, DecodeResponse>({
-        type: 'decode',
-        buffer: encodedBuffer.buffer as ArrayBuffer,
-        encodings
-    }, [encodedBuffer.buffer]);
-
-    return {
-        encoded: Buffer.from(result.inputBuffer),
-        decoded: Buffer.from(result.decodedBuffer)
-    };
+    try {
+        const result = await callApi<DecodeRequest, DecodeResponse>({
+            type: 'decode',
+            buffer: encodedBuffer.buffer as ArrayBuffer,
+            encodings
+        }, [encodedBuffer.buffer]);
+
+        return {
+            encoded: Buffer.from(result.inputBuffer),
+            decoded: Buffer.from(result.decodedBuffer)
+        };
+    } catch (e: any) {
+        // In general, the worker should return the original encoded buffer to us, so we can
+        // show it to the user to help them debug encoding issues:
+        if (e.inputBuffer) {
+            e.inputBuffer = Buffer.from(e.inputBuffer);
+        }
+        throw e;
+    }
 }
 
 export async function encodeBody(decodedBuffer: Buffer, encodings: string[]) {

src/services/ui-worker.ts

@@ -175,11 +175,22 @@ ctx.addEventListener('message', async (event: { data: BackgroundRequest }) => {
     try {
         switch (event.data.type) {
             case 'decode':
-                const decodeResult = await decodeRequest(event.data);
-                ctx.postMessage(decodeResult, [
-                    decodeResult.inputBuffer,
-                    decodeResult.decodedBuffer
-                ]);
+                try {
+                    const decodeResult = await decodeRequest(event.data);
+                    ctx.postMessage(decodeResult, [
+                        decodeResult.inputBuffer,
+                        decodeResult.decodedBuffer
+                    ]);
+                } catch (e: any) {
+                    // Special case for decoding errors: we send the encoded data back with the error, so the user can debug it:
+                    ctx.postMessage({
+                        id: event.data.id,
+                        error: Object.assign(serializeError(e), {
+                            inputBuffer: event.data.buffer
+                        })
+                    }, [event.data.buffer]);
+                    return;
+                }
                 break;
 
             case 'encode':

src/types.d.ts

@@ -129,6 +129,7 @@ export type MessageBody = {
     encoded: { byteLength: number } | Buffer,
     decoded: Buffer | undefined,
     decodedPromise: ObservablePromise<Buffer | undefined>,
+    decodingError: Error | undefined,
     cleanup(): void
 };