Added kind param

Author: mgurgel

special-pages/pages/duckplayer/app/embed-settings.js

@@ -103,9 +103,17 @@ class VideoId {
      * @throws {Error}
      */
     constructor(input) {
-        if (typeof input !== 'string') throw new Error('string required, got: ' + input);
+        if (typeof input !== 'string') {
+            const error = new Error('string required, got: ' + input);
+            error.name = 'VideoIdError';
+            throw error;
+        }
         const sanitized = sanitizeYoutubeId(input);
-        if (sanitized === null) throw new Error('invalid ID from: ' + input);
+        if (sanitized === null) {
+            const error = new Error('invalid ID from: ' + input);
+            error.name = 'VideoIdError';
+            throw error;
+        }
         this.id = sanitized;
     }
 
@@ -126,9 +134,17 @@ class Timestamp {
      * @throws {Error}
      */
     constructor(input) {
-        if (typeof input !== 'string') throw new Error('string required for timestamp');
+        if (typeof input !== 'string') {
+            const error = new Error('string required for timestamp, got: ' + input);
+            error.name = 'TimestampError';
+            throw error;
+        }
         const seconds = timestampInSeconds(input);
-        if (seconds === null) throw new Error('invalid input for timestamp: ' + input);
+        if (seconds === null) {
+            const error = new Error('invalid input for timestamp: ' + input);
+            error.name = 'TimestampError';
+            throw error;
+        }
         this.seconds = seconds;
     }
 

special-pages/pages/duckplayer/app/index.js

@@ -27,11 +27,14 @@ import { YouTubeErrorProvider } from './providers/YouTubeErrorProvider';
 export async function init(messaging, telemetry, baseEnvironment) {
     const result = await callWithRetry(() => messaging.initialSetup());
     if ('error' in result) {
-        throw new Error(result.error);
+        console.error('INITIAL SETUP ERROR', result.error);
+        const error = new Error(result.error);
+        error.name = 'InitialSetupError';
+        throw error;
     }
 
     const init = result.value;
-    console.log('INITIAL DATA', init);
+    console.log('INITIAL DATA');
 
     // update the 'env' in case it was changed by native sides
     const environment = baseEnvironment
@@ -69,10 +72,13 @@ export async function init(messaging, telemetry, baseEnvironment) {
     const embed = createEmbedSettings(window.location.href, settings);
 
     const didCatch = (error) => {
-        const message = error?.message || 'unknown';
-        messaging.reportException({ message });
+        const message = error?.message;
+        const kind = error?.error?.name;
+        messaging.reportException({ message, kind });
+        console.log('reportException', message, kind);
+
         // TODO: Remove the following event once all native platforms are responding to 'reportMetric: exception'
-        messaging.reportPageException({ message });
+        messaging.reportPageException({ message: message || 'unknown error' });
     };
 
     document.body.dataset.layout = settings.layout;

special-pages/pages/duckplayer/app/providers/UserValuesProvider.jsx

@@ -60,9 +60,12 @@ export function UserValuesProvider({ initial, children }) {
             })
             .catch((err) => {
                 console.error('could not set the enabled flag', err);
-                messaging.reportException({ message: 'could not set the enabled flag: ' + err.toString() });
+                const message = 'could not set the enabled flag: ' + err.toString();
+                const kind = 'MessagingError';
+                messaging.reportException({ message, kind });
+
                 // TODO: Remove the following event once all native platforms are responding to 'reportMetric: exception'
-                messaging.reportPageException({ message: 'could not set the enabled flag: ' + err.toString() });
+                messaging.reportPageException({ message });
             });
     }
 

special-pages/pages/duckplayer/integration-tests/duck-player.js

@@ -145,6 +145,14 @@ export class DuckPlayerPage {
         this.mocks.defaultResponses(clone);
     }
 
+    initError() {
+        const clone = structuredClone(this.defaults);
+        // Force an init error by passing an empty response to initialSetup
+        // @ts-expect-error - this is a test
+        clone.initialSetup = undefined;
+        this.mocks.defaultResponses(clone);
+    }
+
     /**
      * We don't need to actually load the content for these tests.
      * By mocking the response, we make the tests about 10x faster and also ensure they work offline.
@@ -537,6 +545,31 @@ export class DuckPlayerPage {
         ]);
     }
 
+    /**
+     * @param {import('../../../shared/types/shared.ts').ReportMetricEvent} evt
+     */
+    async didSendReportMetric(evt) {
+        const events = await this.mocks.waitForCallCount({ method: 'reportMetric', count: 1 });
+        expect(events).toStrictEqual([
+            {
+                payload: {
+                    context: 'specialPages',
+                    featureName: 'duckPlayerPage',
+                    method: 'reportMetric',
+                    params: evt,
+                },
+            },
+        ]);
+    }
+
+    /**
+     * @param {string} kind
+     * @param {string} message
+     */
+    didSendException(kind, message) {
+        return this.didSendReportMetric({ metricName: 'exception', params: { kind, message } });
+    }
+
     async withStorageValues() {
         await this.page.evaluate(() => {
             localStorage.setItem('foo', 'bar');

special-pages/pages/duckplayer/integration-tests/duckplayer.spec.js

@@ -333,6 +333,14 @@ test.describe('reporting exceptions', () => {
         // load as normal
         await duckplayer.openWithException();
         await duckplayer.showsErrorMessage();
+        await duckplayer.didSendException('Error', 'Simulated Exception');
+    });
+    test('initial setup error', async ({ page }, workerInfo) => {
+        const duckplayer = DuckPlayerPage.create(page, workerInfo);
+        // load as normal
+        duckplayer.initError();
+        await duckplayer.openWithVideoID();
+        await duckplayer.didSendException('InitError', 'Max attempts reached: Error: response not found for initialSetup');
     });
 });
 

special-pages/pages/duckplayer/src/index.js

@@ -191,10 +191,12 @@ const telemetry = new Telemetry(messaging);
 init(duckplayerPage, telemetry, baseEnvironment).catch((e) => {
     // messages.
     console.error(e);
-    const msg = typeof e?.message === 'string' ? e.message : 'unknown init error';
-    duckplayerPage.reportException({ message: msg });
+    const message = typeof e?.message === 'string' ? e.message : 'unknown error';
+    const kind = 'InitError';
+    duckplayerPage.reportException({ message, kind });
+
     // TODO: Remove this event once all native platforms are responding to 'reportMetric: exception'
-    duckplayerPage.reportInitException({ message: msg });
+    duckplayerPage.reportInitException({ message });
 });
 
 initStorage();

special-pages/shared/messages/reportMetric.notify.json

@@ -17,6 +17,9 @@
           "properties": {
             "message": {
               "type": "string"
+            },
+            "kind": {
+              "type": "string"
             }
           }
         }

special-pages/shared/report-metric.js

@@ -2,14 +2,16 @@ export const REPORT_METRIC_MESSAGE_ID = 'reportMetric';
 export const METRIC_NAME_EXCEPTION = 'exception';
 
 /**
+ * @typedef {import('../shared/types/shared.ts').ExceptionMetric} ExceptionMetric
+ * @typedef {import('../shared/types/shared.ts').ReportMetricEvent} ReportMetricEvent
  * @typedef {import('../shared/types/shared.ts').SharedMessages} SharedMessages
  * @typedef {import('@duckduckgo/messaging/lib/shared-types.js').MessagingBase<SharedMessages>|import('@duckduckgo/messaging').Messaging} SharedMessaging
  */
 
 /**
  * Sends a standard 'reportMetric' event to the native layer
  * @param {SharedMessaging} messaging
- * @param {import('../shared/types/shared.ts').ReportMetricEvent} metricEvent
+ * @param {ReportMetricEvent} metricEvent
  */
 export function reportMetric(messaging, metricEvent) {
     if (!messaging?.notify) {
@@ -26,8 +28,19 @@ export function reportMetric(messaging, metricEvent) {
 /**
  * Sends a 'reportMetric' event with metric name 'exception'
  * @param {SharedMessaging} messaging
- * @param {import('../shared/types/shared.ts').ExceptionMetric['params']} params
+ * @param {ExceptionMetric['params']} params
  */
 export function reportException(messaging, params) {
-    reportMetric(messaging, { metricName: METRIC_NAME_EXCEPTION, params });
+    const message = typeof params?.message === 'string' ? params.message : 'unknown error';
+    const kind = typeof params?.kind === 'string' ? params.kind : 'Error';
+
+    /** @type {ExceptionMetric} */
+    const metric = {
+        metricName: METRIC_NAME_EXCEPTION,
+        params: {
+            message,
+            kind,
+        },
+    };
+    reportMetric(messaging, metric);
 }

special-pages/shared/types/shared.ts

@@ -25,5 +25,6 @@ export interface ExceptionMetric {
   metricName: "exception";
   params: {
     message: string;
+    kind?: string;
   };
 }