✨ Allow to modify source_url property in Loaf script attributions

packages/rum-core/src/domain/assembly.ts

@@ -100,6 +100,8 @@ export function startRumAssembly(
       ...ROOT_MODIFIABLE_FIELD_PATHS,
     },
     [RumEventType.LONG_TASK]: {
+      'long_task.scripts[].source_url': 'string',
+      'long_task.scripts[].invoker': 'string',
       ...USER_CUSTOMIZABLE_FIELD_PATHS,
       ...VIEW_MODIFIABLE_FIELD_PATHS,
     },

packages/rum-core/src/domain/limitModification.spec.ts

@@ -4,38 +4,57 @@ import type { ModifiableFieldPaths } from './limitModification'
 import { limitModification } from './limitModification'
 
 describe('limitModification', () => {
+  let object: unknown
+
+  beforeEach(() => {
+    object = {
+      foo: { bar: 'bar' },
+      arr: [{ foo: 'foo' }],
+      qux: 'qux',
+    }
+  })
+
   it('should allow modifications on modifiable field', () => {
-    const object = { foo: { bar: 'bar' }, qux: 'qux' }
     const modifier = (candidate: any) => {
       candidate.foo.bar = 'modified1'
       candidate.qux = 'modified2'
+      candidate.arr[0].foo = 'modified3'
     }
 
-    limitModification(object, { 'foo.bar': 'string', qux: 'string' }, modifier)
+    limitModification(
+      object,
+      {
+        'foo.bar': 'string',
+        qux: 'string',
+        'arr[].foo': 'string',
+      },
+      modifier
+    )
 
     expect(object).toEqual({
       foo: { bar: 'modified1' },
       qux: 'modified2',
+      arr: [{ foo: 'modified3' }],
     })
   })
 
   it('should not allow modifications on non modifiable field', () => {
-    const object = { foo: { bar: 'bar' }, qux: 'qux' }
     const modifier = (candidate: any) => {
       candidate.foo.bar = 'modified1'
       candidate.qux = 'modified2'
+      candidate.arr[0].foo = 'modified3'
     }
 
     limitModification(object, { 'foo.bar': 'string' }, modifier)
 
     expect(object).toEqual({
       foo: { bar: 'modified1' },
+      arr: [{ foo: 'foo' }],
       qux: 'qux',
     })
   })
 
   it('should allow to add a modifiable fields not present on the original object', () => {
-    const object = { foo: { bar: 'bar' }, qux: 'qux' }
     const modifier = (candidate: any) => {
       candidate.foo.bar = 'modified1'
       candidate.qux = 'modified2'
@@ -46,13 +65,13 @@ describe('limitModification', () => {
 
     expect(object as any).toEqual({
       foo: { bar: 'modified1' },
+      arr: [{ foo: 'foo' }],
       qux: 'modified2',
       qix: 'modified3',
     })
   })
 
   it('should not allow to add a non modifiable fields not present on the original object', () => {
-    const object = { foo: { bar: 'bar' }, qux: 'qux' }
     const modifier = (candidate: any) => {
       candidate.foo.bar = 'modified1'
       candidate.qux = 'modified2'
@@ -63,6 +82,7 @@ describe('limitModification', () => {
 
     expect(object).toEqual({
       foo: { bar: 'modified1' },
+      arr: [{ foo: 'foo' }],
       qux: 'modified2',
     })
   })
@@ -119,18 +139,19 @@ describe('limitModification', () => {
   })
 
   it('should not allow structural change of the object', () => {
-    const object = { foo: { bar: 'bar' }, qux: 'qux' }
     const modifier = (candidate: any) => {
       candidate.foo.bar = { qux: 'qux' }
       candidate.bar = 'bar'
       delete candidate.qux
+      ;(candidate.arr as Array<Record<string, string>>).push({ bar: 'baz' })
     }
 
     limitModification(object, { 'foo.bar': 'string', qux: 'string' }, modifier)
 
     expect(object).toEqual({
       foo: { bar: 'bar' },
       qux: 'qux',
+      arr: [{ foo: 'foo' }],
     })
   })
 

packages/rum-core/src/domain/limitModification.ts

@@ -4,8 +4,9 @@ import type { Context } from '@datadog/browser-core'
 export type ModifiableFieldPaths = Record<string, 'string' | 'object'>
 
 /**
- * Current limitation:
- * - field path do not support array, 'a.b.c' only
+ * Allows declaring and enforcing modifications to specific fields of an object.
+ * Only supports modifying properties of an object (even if nested in an array).
+ * Does not support array manipulation (adding/removing items).
  */
 export function limitModification<T extends Context, Result>(
   object: T,
@@ -14,43 +15,79 @@ export function limitModification<T extends Context, Result>(
 ): Result | undefined {
   const clone = deepClone(object)
   const result = modifier(clone)
+
+  // Validate the modified fields and assign them back to 'original' if they match the expected type.
   objectEntries(modifiableFieldPaths).forEach(([fieldPath, fieldType]) => {
-    const newValue = get(clone, fieldPath)
-    const newType = getType(newValue)
-    if (newType === fieldType) {
-      set(object, fieldPath, sanitize(newValue))
+    const pathSegments = fieldPath.split(/\.|(?=\[\])/)
+    const newValue = getValueFromPath(clone, pathSegments)
+    const newType = getTypes(newValue)
+
+    if (isValidType(newType, fieldType)) {
+      setValueAtPath(object, pathSegments, sanitizeValues(newValue))
     } else if (fieldType === 'object' && (newType === 'undefined' || newType === 'null')) {
-      set(object, fieldPath, {})
+      setValueAtPath(object, pathSegments, {})
     }
   })
+
   return result
 }
 
-function get(object: unknown, path: string) {
-  let current = object
-  for (const field of path.split('.')) {
-    if (!isValidObjectContaining(current, field)) {
+function getValueFromPath(object: unknown, pathSegments: string[]): unknown {
+  const [field, ...restPathSegments] = pathSegments
+
+  if (field === '[]') {
+    if (!Array.isArray(object)) {
       return
     }
-    current = current[field]
+
+    return object.map((item) => getValueFromPath(item, restPathSegments))
+  }
+
+  return getNestedValue(object, pathSegments)
+}
+
+function getNestedValue(object: unknown, pathSegments: string[]): unknown {
+  const [field, ...restPathSegments] = pathSegments
+
+  if (!isValidObjectContaining(object, field)) {
+    return
+  }
+
+  if (restPathSegments.length === 0) {
+    return object[field]
   }
-  return current
+
+  return getValueFromPath(object[field], restPathSegments)
 }
 
-function set(object: unknown, path: string, value: unknown) {
-  let current = object
-  const fields = path.split('.')
-  for (let i = 0; i < fields.length; i += 1) {
-    const field = fields[i]
-    if (!isValidObject(current)) {
+function setValueAtPath(object: unknown, pathSegments: string[], value: unknown) {
+  const [field, ...restPathSegments] = pathSegments
+
+  if (field === '[]') {
+    if (!Array.isArray(object) || !Array.isArray(value)) {
       return
     }
-    if (i !== fields.length - 1) {
-      current = current[field]
-    } else {
-      current[field] = value
-    }
+
+    object.forEach((item, i) => setValueAtPath(item, restPathSegments, value[i]))
+    return
+  }
+
+  setNestedValue(object, pathSegments, value)
+}
+
+function setNestedValue(object: unknown, pathSegments: string[], value: unknown) {
+  const [field, ...restPathSegments] = pathSegments
+
+  if (!isValidObject(object)) {
+    return
+  }
+
+  if (restPathSegments.length === 0) {
+    object[field] = value
+    return
   }
+
+  setValueAtPath(object[field], restPathSegments, value)
 }
 
 function isValidObject(object: unknown): object is Record<string, unknown> {
@@ -60,3 +97,27 @@ function isValidObject(object: unknown): object is Record<string, unknown> {
 function isValidObjectContaining(object: unknown, field: string): object is Record<string, unknown> {
   return isValidObject(object) && Object.prototype.hasOwnProperty.call(object, field)
 }
+
+function isValidType(actualType: string | string[], expectedType: 'string' | 'object'): boolean {
+  if (Array.isArray(actualType)) {
+    return actualType.length > 0 && actualType.every((type) => type === expectedType)
+  }
+
+  return actualType === expectedType
+}
+
+function sanitizeValues(thing: unknown) {
+  if (Array.isArray(thing)) {
+    return thing.map((item) => sanitize(item))
+  }
+
+  return sanitize(thing)
+}
+
+function getTypes(thing: unknown) {
+  if (Array.isArray(thing)) {
+    return thing.map((item) => getType(item))
+  }
+
+  return getType(thing)
+}