fix: record resources with invalid names (#532)

* fix: Ignore URL construction error from invalid performance resource event

* fix: Throw error when URL construction fails for invalid performance resource event

* fix: Ignore error thrown from URL construction

* test: add unit test

* fix: record resources with invalid names

* fix: Update unit test for invalid url

* fix: Update hostname typo in isPutRumEventsCall tests

---------

Co-authored-by: Billy <[email protected]>

Author: shubhsheth

src/plugins/event-plugins/ResourcePlugin.ts

@@ -1,5 +1,9 @@
 import { InternalPlugin } from '../InternalPlugin';
-import { getResourceFileType, shuffle } from '../../utils/common-utils';
+import {
+    getResourceFileType,
+    isPutRumEventsCall,
+    shuffle
+} from '../../utils/common-utils';
 import { ResourceEvent } from '../../events/resource-event';
 import { PERFORMANCE_RESOURCE_EVENT_TYPE } from '../utils/constant';
 import {
@@ -88,12 +92,8 @@ export class ResourcePlugin extends InternalPlugin {
         duration,
         transferSize
     }: PerformanceResourceTiming): void => {
-        const pathRegex =
-            /.*\/application\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\/events/;
-        const entryUrl = new URL(name);
         if (
-            entryUrl.host === this.context.config.endpointUrl.host &&
-            pathRegex.test(entryUrl.pathname)
+            isPutRumEventsCall(name, this.context.config.endpointUrl.hostname)
         ) {
             // Ignore calls to PutRumEvents (i.e., the CloudWatch RUM data
             // plane), otherwise we end up in an infinite loop of recording

src/plugins/event-plugins/__tests__/ResourcePlugin.test.ts

@@ -1,8 +1,6 @@
 import {
     resourceTiming,
     putRumEventsDocument,
-    putRumEventsGammaDocument,
-    dataPlaneDocument,
     imageResourceEventA,
     imageResourceEventB,
     navigationEvent,
@@ -95,32 +93,6 @@ describe('ResourcePlugin tests', () => {
         expect(record).not.toHaveBeenCalled();
     });
 
-    test('when resource is a PutRumEvents request with a path prefix then resource event is not recorded', async () => {
-        // Setup
-        doMockPerformanceObserver([putRumEventsGammaDocument]);
-
-        const plugin: ResourcePlugin = buildResourcePlugin();
-
-        // Run
-        plugin.load(context);
-
-        // Assert
-        expect(record).not.toHaveBeenCalled();
-    });
-
-    test('when resource is not a PutRumEvents request but has the same host then the resource event is recorded', async () => {
-        // Setup
-        doMockPerformanceObserver([dataPlaneDocument]);
-
-        const plugin: ResourcePlugin = buildResourcePlugin();
-
-        // Run
-        plugin.load(context);
-
-        // Assert
-        expect(record).toHaveBeenCalled();
-    });
-
     test('when enabled then events are recorded', async () => {
         // Setup
         const plugin: ResourcePlugin = buildResourcePlugin();
@@ -235,4 +207,28 @@ describe('ResourcePlugin tests', () => {
 
         expect(record).not.toHaveBeenCalled();
     });
+
+    test('when entry name is an invalid url then resource event is recorded', async () => {
+        // setup
+        const invalidEntry = {
+            name: 'invalid.com',
+            startTime: 0,
+            duration: 10,
+            entryType: 'resource'
+        } as PerformanceEntry;
+        doMockPerformanceObserver([invalidEntry]);
+
+        // run
+        const plugin = buildResourcePlugin();
+        plugin.load(context);
+
+        // assert
+        expect(() => new URL(invalidEntry.name)).toThrowError();
+        expect(() =>
+            plugin.recordResourceEvent(
+                invalidEntry as PerformanceResourceTiming
+            )
+        ).not.toThrowError();
+        expect(record).toHaveBeenCalled();
+    });
 });

src/utils/__tests__/common-utils.test.ts

@@ -105,4 +105,33 @@ describe('Common utils tests', () => {
             utils.getResourceFileType(resourceUrl, utils.InitiatorType.CSS)
         ).toEqual(utils.ResourceType.STYLESHEET);
     });
+
+    test('when url is has endpoint host and path then it is a PutRumEvents call', async () => {
+        const endpointHost = 'dataplane.rum.us-west-2.amazonaws.com';
+        const resourceUrl =
+            'https://dataplane.rum.us-west-2.amazonaws.com/gamma/application/aa17a42c-e737-48f7-adaf-2e0905f48073/events';
+        expect(utils.isPutRumEventsCall(resourceUrl, endpointHost)).toBe(true);
+    });
+
+    test('when url has endpoint host but wrong path then it is not a PutRumEvents call', async () => {
+        const endpointHost = 'dataplane.rum.us-west-2.amazonaws.com';
+        const resourceUrl =
+            'https://dataplane.rum.us-west-2.amazonaws.com/user';
+        expect(utils.isPutRumEventsCall(resourceUrl, endpointHost)).toBe(false);
+    });
+
+    test('when url has wrong host and wrong path then it is not a PutRumEvents call', async () => {
+        const endpointHost = 'example.com';
+        const resourceUrl =
+            'https://dataplane.rum.us-west-2.amazonaws.com/user';
+        expect(utils.isPutRumEventsCall(resourceUrl, endpointHost)).toBe(false);
+    });
+
+    test('when url is invalid then it is not a PutRumEvents call', async () => {
+        const endpointHost = 'dataplane.rum.us-west-2.amazonaws.com';
+        const resourceUrl =
+            'dataplane.rum.us-west-2.amazonaws.com/gamma/application/aa17a42c-e737-48f7-adaf-2e0905f48073/events';
+        expect(() => new URL(endpointHost)).toThrowError();
+        expect(utils.isPutRumEventsCall(resourceUrl, endpointHost)).toBe(false);
+    });
 });

src/utils/common-utils.ts

@@ -222,3 +222,22 @@ export const isFCPSupported = () => {
 export const isLongTaskSupported = () => {
     return PerformanceObserver.supportedEntryTypes.includes('longtask');
 };
+
+/** PutRumEvents regex pattern */
+const putRumEventsPattern =
+    /.*\/application\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\/events/;
+
+export const isPutRumEventsCall = (
+    url: string,
+    endpointHost: string
+): boolean => {
+    try {
+        return (
+            new URL(url).hostname === endpointHost &&
+            putRumEventsPattern.test(url)
+        );
+    } catch (_) {
+        // Ignore invalid URLs
+        return false;
+    }
+};