✨ [RUM-14736] Add size to ResourceStopOptions (#4296)

Author: BeltranBulbarellaDD

packages/rum-core/src/boot/rumPublicApi.spec.ts

@@ -840,7 +840,8 @@ describe('rum public api', () => {
       rumPublicApi.stopResource('https://api.example.com/data', {
         type: ResourceType.XHR,
         statusCode: 200,
-        context: { responseSize: 1024 },
+        size: 1024,
+        context: { requestId: 'abc' },
       })
 
       expect(startResourceSpy).toHaveBeenCalledWith(
@@ -856,7 +857,8 @@ describe('rum public api', () => {
         jasmine.objectContaining({
           type: ResourceType.XHR,
           statusCode: 200,
-          context: { responseSize: 1024 },
+          size: 1024,
+          context: { requestId: 'abc' },
         })
       )
     })

packages/rum-core/src/boot/rumPublicApi.ts

@@ -749,6 +749,7 @@ export function makeRumPublicApi(
       strategy.stopResource(sanitize(url)!, {
         type: sanitize(options && options.type) as ResourceType | undefined,
         statusCode: options && options.statusCode,
+        size: options && options.size,
         context: sanitize(options && options.context) as Context,
         resourceKey: options && options.resourceKey,
       })

packages/rum-core/src/domain/resource/trackManualResources.spec.ts

@@ -112,6 +112,26 @@ describe('trackManualResources', () => {
     })
   })
 
+  describe('size', () => {
+    it('should include size when provided at stop', () => {
+      startResource('https://api.example.com/data')
+      stopResource('https://api.example.com/data', { size: 1234 })
+
+      expect(rawRumEvents).toHaveSize(1)
+      const resourceEvent = rawRumEvents[0].rawRumEvent as RawRumResourceEvent
+      expect(resourceEvent.resource.size).toBe(1234)
+    })
+
+    it('should leave size undefined when not provided', () => {
+      startResource('https://api.example.com/data')
+      stopResource('https://api.example.com/data')
+
+      expect(rawRumEvents).toHaveSize(1)
+      const resourceEvent = rawRumEvents[0].rawRumEvent as RawRumResourceEvent
+      expect(resourceEvent.resource.size).toBeUndefined()
+    })
+  })
+
   describe('resourceKey', () => {
     it('should support resourceKey for tracking same url multiple times', () => {
       startResource('https://api.example.com/data', { resourceKey: 'request1' })

packages/rum-core/src/domain/resource/trackManualResources.ts

@@ -1,4 +1,4 @@
-import type { ClocksState, Context, ResourceType } from '@datadog/browser-core'
+import type { Context, ResourceType } from '@datadog/browser-core'
 import { clocksNow, elapsed, ResourceType as ResourceTypeEnum, toServerDuration } from '@datadog/browser-core'
 import type { RawRumResourceEvent } from '../../rawRumEvent.types'
 import { RumEventType } from '../../rawRumEvent.types'
@@ -42,6 +42,11 @@ export interface ResourceStopOptions {
    */
   statusCode?: number
 
+  /**
+   * Resource size in bytes
+   */
+  size?: number
+
   /**
    * Resource context
    */
@@ -61,38 +66,6 @@ export interface ManualResourceData {
 }
 
 export function trackManualResources(lifeCycle: LifeCycle, resourceTracker: EventTracker<ManualResourceData>) {
-  function emitResource(
-    id: string,
-    startClocks: ClocksState,
-    data: ManualResourceData,
-    statusCode?: number,
-    endClocks?: ClocksState
-  ) {
-    const duration = endClocks ? elapsed(startClocks.relative, endClocks.relative) : undefined
-
-    const rawRumEvent: RawRumResourceEvent = {
-      date: startClocks.timeStamp,
-      type: RumEventType.RESOURCE,
-      resource: {
-        id,
-        type: data.type || ResourceTypeEnum.OTHER,
-        url: sanitizeIfLongDataUrl(data.url),
-        duration: duration !== undefined ? toServerDuration(duration) : undefined,
-        method: data.method,
-        status_code: statusCode,
-      },
-      _dd: {},
-      context: data.context,
-    }
-
-    lifeCycle.notify(LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, {
-      rawRumEvent,
-      startClocks,
-      duration,
-      domainContext: { isManual: true as const },
-    })
-  }
-
   function startManualResource(url: string, options: ResourceOptions = {}, startClocks = clocksNow()) {
     const lookupKey = options.resourceKey ?? url
 
@@ -114,7 +87,30 @@ export function trackManualResources(lifeCycle: LifeCycle, resourceTracker: Even
       return
     }
 
-    emitResource(stopped.id, stopped.startClocks, stopped, options.statusCode, stopClocks)
+    const duration = elapsed(stopped.startClocks.relative, stopClocks.relative)
+
+    const rawRumEvent: RawRumResourceEvent = {
+      date: stopped.startClocks.timeStamp,
+      type: RumEventType.RESOURCE,
+      resource: {
+        id: stopped.id,
+        type: stopped.type || ResourceTypeEnum.OTHER,
+        url: sanitizeIfLongDataUrl(stopped.url),
+        duration: toServerDuration(duration),
+        method: stopped.method,
+        status_code: options.statusCode,
+        size: options.size,
+      },
+      _dd: {},
+      context: stopped.context,
+    }
+
+    lifeCycle.notify(LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, {
+      rawRumEvent,
+      startClocks: stopped.startClocks,
+      duration,
+      domainContext: { isManual: true },
+    })
   }
 
   return {