@kubesense/kubesense-browser-rum-core 1.7.0 → 2.0.0-beta.1

package/src/domain/getSelectorFromElement.ts

@@ -1,5 +1,15 @@
+import { isNodeShadowRoot } from '../browser/htmlDomUtils'
 import { DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE } from './action/actionNameConstants'
 
+/**
+ * Marker used to indicate shadow DOM boundaries in selectors.
+ * Named after the deprecated Shadow DOM v0 '::shadow' pseudo-element which served the same
+ * purpose of marking entry into a shadow root.
+ * Note: This is NOT a valid CSS selector, it's an internal marker that requires custom
+ * parsing logic.
+ */
+export const SHADOW_DOM_MARKER = '::shadow '
+
 /**
  * Stable attributes are attributes that are commonly used to identify parts of a UI (ex:
  * component). Those attribute values should not be generated randomly (hardcoded most of the time)
@@ -37,6 +47,11 @@ const UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS: SelectorGetter[] = [
   getTagNameSelector,
 ]
 
+interface SubtreeTarget {
+  rootNode: Document | ShadowRoot
+  target: Element
+}
+
 export function getSelectorFromElement(
   targetElement: Element,
   actionNameAttribute: string | undefined
@@ -46,38 +61,85 @@ export function getSelectorFromElement(
     // parents, and we cannot determine if it's unique in the document.
     return
   }
-  let targetElementSelector: string | undefined
+
+  const subtrees = getAllSubtreeTargets(targetElement)
+  const selectorParts: string[] = []
+
+  for (const { rootNode, target } of subtrees) {
+    const selector = getSelectorFromElementWithinSubtree(target, rootNode, actionNameAttribute)
+    if (!selector) {
+      return undefined
+    }
+    selectorParts.push(selector)
+  }
+
+  return selectorParts.join(SHADOW_DOM_MARKER)
+}
+
+/**
+ * Returns all (rootNode, target) pairs from the document down to the element.
+ */
+function getAllSubtreeTargets(element: Element): SubtreeTarget[] {
+  const result: SubtreeTarget[] = []
+  let currentTarget: Element | undefined = element
+
+  while (currentTarget) {
+    const rootNode = currentTarget.getRootNode() as Document | ShadowRoot
+    result.push({ rootNode, target: currentTarget })
+
+    if (isNodeShadowRoot(rootNode)) {
+      currentTarget = rootNode.host
+    } else {
+      break
+    }
+  }
+
+  return result.reverse()
+}
+
+/**
+ * Computes a CSS selector for an element within a specific subtree (document or shadow root).
+ */
+function getSelectorFromElementWithinSubtree(
+  targetElement: Element,
+  rootNode: Document | ShadowRoot,
+  actionNameAttribute: string | undefined
+): string | undefined {
+  let currentSelector: string | undefined
   let currentElement: Element | null = targetElement
 
   while (currentElement && currentElement.nodeName !== 'HTML') {
     const globallyUniqueSelector = findSelector(
       currentElement,
+      rootNode,
       GLOBALLY_UNIQUE_SELECTOR_GETTERS,
-      isSelectorUniqueGlobally,
+      isSelectorUniqueWithinRoot,
       actionNameAttribute,
-      targetElementSelector
+      currentSelector
     )
     if (globallyUniqueSelector) {
-      return globallyUniqueSelector
+      return combineSelector(globallyUniqueSelector, currentSelector)
     }
 
     const uniqueSelectorAmongChildren = findSelector(
       currentElement,
+      rootNode,
       UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS,
       isSelectorUniqueAmongSiblings,
       actionNameAttribute,
-      targetElementSelector
+      currentSelector
     )
-    targetElementSelector =
-      uniqueSelectorAmongChildren || combineSelector(getPositionSelector(currentElement), targetElementSelector)
+
+    const elementSelector = uniqueSelectorAmongChildren || getPositionSelector(currentElement)
+    currentSelector = combineSelector(elementSelector, currentSelector)
 
     currentElement = currentElement.parentElement
   }
 
-  return targetElementSelector
+  return currentSelector
 }
 
-function isGeneratedValue(value: string) {
+export function isGeneratedValue(value: string) {
   // To compute the "URL path group", the backend replaces every URL path parts as a question mark
   // if it thinks the part is an identifier. The condition it uses is to checks whether a digit is
   // present.
@@ -88,7 +150,7 @@ function isGeneratedValue(value: string) {
   return /[0-9]/.test(value)
 }
 
-function getIDSelector(element: Element): string | undefined {
+export function getIDSelector(element: Element): string | undefined {
   if (element.id && !isGeneratedValue(element.id)) {
     return `#${CSS.escape(element.id)}`
   }
@@ -109,7 +171,7 @@ function getClassSelector(element: Element): string | undefined {
   }
 }
 
-function getTagNameSelector(element: Element): string {
+export function getTagNameSelector(element: Element): string {
   return CSS.escape(element.tagName)
 }
 
@@ -130,29 +192,48 @@ function getStableAttributeSelector(element: Element, actionNameAttribute: strin
 
   function getAttributeSelector(attributeName: string) {
     if (element.hasAttribute(attributeName)) {
-      return `${CSS.escape(element.tagName)}[${attributeName}="${CSS.escape(element.getAttribute(attributeName)!)}"]`
+      return `${CSS.escape(element.tagName)}${getAttributeValueSelector(attributeName, element.getAttribute(attributeName)!)}`
     }
   }
 }
 
+export function getAttributeValueSelector(attributeName: string, attributeValue: string) {
+  return `[${attributeName}="${CSS.escape(attributeValue)}"]`
+}
+
 function getPositionSelector(element: Element): string {
-  let sibling = element.parentElement!.firstElementChild
-  let elementIndex = 1
+  const nthOfType = getNthOfTypeSelector(element)
+
+  return `${CSS.escape(element.tagName)}:nth-of-type(${nthOfType})`
+}
+
+export function getNthOfTypeSelector(element: Element): number {
+  const parent = element.parentNode!
+
+  let sibling = parent.firstElementChild
+
+  let nthOfType = 1
 
   while (sibling && sibling !== element) {
     if (sibling.tagName === element.tagName) {
-      elementIndex += 1
+      nthOfType += 1
     }
     sibling = sibling.nextElementSibling
   }
 
-  return `${CSS.escape(element.tagName)}:nth-of-type(${elementIndex})`
+  return nthOfType
 }
 
 function findSelector(
   element: Element,
+  rootNode: Document | ShadowRoot,
   selectorGetters: SelectorGetter[],
-  predicate: (element: Element, elementSelector: string, childSelector: string | undefined) => boolean,
+  predicate: (
+    element: Element,
+    rootNode: Document | ShadowRoot,
+    elementSelector: string,
+    childSelector: string | undefined
+  ) => boolean,
   actionNameAttribute: string | undefined,
   childSelector: string | undefined
 ) {
@@ -161,34 +242,34 @@ function findSelector(
     if (!elementSelector) {
       continue
     }
-    if (predicate(element, elementSelector, childSelector)) {
-      return combineSelector(elementSelector, childSelector)
+    if (predicate(element, rootNode, elementSelector, childSelector)) {
+      return elementSelector
     }
   }
 }
 
 /**
- * Check whether the selector is unique among the whole document.
+ * Check whether the selector is unique within the root node (document or shadow root).
  */
-function isSelectorUniqueGlobally(
-  element: Element,
+function isSelectorUniqueWithinRoot(
+  _element: Element,
+  rootNode: Document | ShadowRoot,
   elementSelector: string,
   childSelector: string | undefined
 ): boolean {
-  return element.ownerDocument.querySelectorAll(combineSelector(elementSelector, childSelector)).length === 1
+  return rootNode.querySelectorAll(combineSelector(elementSelector, childSelector)).length === 1
 }
 
 /**
  * Check whether the selector is unique among the element siblings. In other words, it returns true
  * if "ELEMENT_PARENT > CHILD_SELECTOR" returns a single element.
  *
- * @param {Element} currentElement - the element being considered while iterating over the target
+ * @param currentElement - the element being considered while iterating over the target
  * element ancestors.
- *
- * @param {string} currentElementSelector - a selector that matches the current element. That
+ * @param _rootNode - the root node (document or shadow root) - unused but required for predicate signature.
+ * @param currentElementSelector - a selector that matches the current element. That
  * selector is not a composed selector (i.e. it might be a single tag name, class name...).
- *
- * @param {string|undefined} childSelector - child selector is a selector that targets a descendant
+ * @param childSelector - child selector is a selector that targets a descendant
  * of the current element. When undefined, the current element is the target element.
  *
  * # Scope selector usage
@@ -236,6 +317,7 @@ function isSelectorUniqueGlobally(
  */
 export function isSelectorUniqueAmongSiblings(
   currentElement: Element,
+  _rootNode: Document | ShadowRoot,
   currentElementSelector: string,
   childSelector: string | undefined
 ): boolean {
@@ -251,10 +333,22 @@ export function isSelectorUniqueAmongSiblings(
     isSiblingMatching = (sibling) => sibling.querySelector(scopedSelector) !== null
   }
 
-  const parent = currentElement.parentElement!
-  let sibling = parent.firstElementChild
+  // Check siblings by iterating directly through previousElementSibling and nextElementSibling.
+  // This works even when parentElement is null (e.g., when parent is a DocumentFragment).
+
+  // Check previous siblings
+  let sibling = currentElement.previousElementSibling
+  while (sibling) {
+    if (isSiblingMatching(sibling)) {
+      return false
+    }
+    sibling = sibling.previousElementSibling
+  }
+
+  // Check next siblings
+  sibling = currentElement.nextElementSibling
   while (sibling) {
-    if (sibling !== currentElement && isSiblingMatching(sibling)) {
+    if (isSiblingMatching(sibling)) {
       return false
     }
     sibling = sibling.nextElementSibling

package/src/domain/getSessionReplayUrl.ts

@@ -1,7 +1,6 @@
-import { INTAKE_SITE_STAGING, INTAKE_SITE_PROD } from '@kubesense/kubesense-browser-core'
+import type { SessionContext } from '@kubesense/kubesense-browser-core'
 import type { RumConfiguration } from './configuration'
 import type { ViewHistoryEntry } from './contexts/viewHistory'
-import type { RumSession } from './rumSessionManager'
 
 export function getSessionReplayUrl(
   configuration: RumConfiguration,
@@ -10,7 +9,7 @@ export function getSessionReplayUrl(
     viewContext,
     errorType,
   }: {
-    session?: RumSession
+    session?: SessionContext
     viewContext?: ViewHistoryEntry
     errorType?: string
   }
@@ -31,17 +30,9 @@ export function getSessionReplayUrl(
 }
 
 export function getKubeSenseSiteUrl(rumConfiguration: RumConfiguration) {
+  // KubeSense installations address the collector host directly, so there is no per-site default
+  // subdomain to derive: only an explicitly configured `subdomain` is prepended.
   const site = rumConfiguration.kubesenseRumEndpoint
   const subdomain = rumConfiguration.subdomain
   return `https://${subdomain ? `${subdomain}.` : ''}${site}`
 }
-
-function getSiteDefaultSubdomain(configuration: RumConfiguration): string | undefined {
-  switch (configuration.kubesenseRumEndpoint) {
-    case INTAKE_SITE_PROD:
-    case INTAKE_SITE_STAGING:
-      return 'staging'
-    default:
-      return undefined
-  }
-}

package/src/domain/hooks.ts

@@ -1,31 +1,44 @@
-import type {
-  DISCARDED,
-  Duration,
-  HookNamesAsConst,
-  RecursivePartial,
-  RelativeTime,
-  SKIPPED,
-  TelemetryEvent,
-} from '@kubesense/kubesense-browser-core'
-import { abstractHooks } from '@kubesense/kubesense-browser-core'
+import type { Duration, RelativeTime } from '@kubesense/kubesense-js-core/time'
+import type { TelemetryEvent } from '@kubesense/kubesense-browser-core'
+import { createHook } from '@kubesense/kubesense-js-core/assembly'
+import type { Hook } from '@kubesense/kubesense-js-core/assembly'
+import type { RecursivePartial } from '@kubesense/kubesense-js-core/util'
 import type { RumEvent } from '../rumEvent.types'
+import type { RawRumEvent } from '../rawRumEvent.types'
+import type { RumEventDomainContext } from '../domainContext.types'
 
 // Define a partial RUM event type.
 // Ensuring the `type` field is always present improves type checking, especially in conditional logic in hooks (e.g., `if (eventType === 'view')`).
 export type DefaultRumEventAttributes = RecursivePartial<RumEvent> & { type: RumEvent['type'] }
 export type DefaultTelemetryEventAttributes = RecursivePartial<TelemetryEvent>
 
-export interface HookCallbackMap {
-  [HookNamesAsConst.ASSEMBLE]: (param: {
-    eventType: RumEvent['type']
-    startTime: RelativeTime
-    duration?: Duration | undefined
-  }) => DefaultRumEventAttributes | SKIPPED | DISCARDED
-  [HookNamesAsConst.ASSEMBLE_TELEMETRY]: (param: {
-    startTime: RelativeTime
-  }) => DefaultTelemetryEventAttributes | SKIPPED | DISCARDED
+type DeepReadonly<T> = {
+  readonly [K in keyof T]: DeepReadonly<T[K]>
 }
 
-export type Hooks = ReturnType<typeof createHooks>
+// Use readonly and DeepReadonly to prevents assemble hook callbacks from mutating the inputs.
+// DeepReadonly is only applied to objects rather than the entire AssembleHookParams to avoid casts for primitives.
+export interface AssembleHookParams {
+  readonly eventType: RumEvent['type']
+  rawRumEvent: DeepReadonly<RawRumEvent>
+  domainContext: DeepReadonly<RumEventDomainContext<RawRumEvent['type']>>
+  readonly startTime: RelativeTime
+  readonly duration?: Duration | undefined
+}
+
+export type AssembleHook = Hook<AssembleHookParams, DefaultRumEventAttributes>
+export type AssembleTelemetryHook = Hook<{ startTime: RelativeTime }, DefaultTelemetryEventAttributes>
 
-export const createHooks = abstractHooks<HookCallbackMap>
+export interface Hooks {
+  assembleEventDefaults: AssembleHook
+  assembleTelemetry: AssembleTelemetryHook
+  assembleEvent: AssembleHook
+}
+
+export function createHooks(): Hooks {
+  return {
+    assembleEventDefaults: createHook(),
+    assembleTelemetry: createHook(),
+    assembleEvent: createHook(),
+  }
+}

package/src/domain/lifeCycle.ts

@@ -1,10 +1,16 @@
-import type { Context, Duration, PageMayExitEvent, RawError, RelativeTime } from '@kubesense/kubesense-browser-core'
+import type { ClocksState, Duration } from '@kubesense/kubesense-js-core/time'
+import type { Context, RawError, UrgentFlushReason } from '@kubesense/kubesense-browser-core'
 import { AbstractLifeCycle } from '@kubesense/kubesense-browser-core'
 import type { RumEventDomainContext } from '../domainContext.types'
 import type { RawRumEvent, AssembledRumEvent } from '../rawRumEvent.types'
 import type { RequestCompleteEvent, RequestStartEvent } from './requestCollection'
+import type { WebSocketCompleteEvent } from './resource/webSocketCollection'
 import type { AutoAction } from './action/actionCollection'
 import type { ViewEvent, ViewCreatedEvent, ViewEndedEvent, BeforeViewUpdateEvent } from './view/trackViews'
+import type { DurationVitalStart } from './vital/vitalCollection'
+import type { TrackedEventData } from './eventTracker'
+import type { ActionEventData } from './action/trackManualActions'
+import type { SessionExpiredEvent } from './session/session.types'
 
 export const enum LifeCycleEventType {
   // Contexts (like viewHistory) should be opened using prefixed BEFORE_XXX events and closed using prefixed AFTER_XXX events
@@ -18,6 +24,7 @@ export const enum LifeCycleEventType {
   AFTER_VIEW_ENDED,
   REQUEST_STARTED,
   REQUEST_COMPLETED,
+  WEBSOCKET_COMPLETED,
 
   // The SESSION_EXPIRED lifecycle event has been introduced to represent when a session has expired
   // and trigger cleanup tasks related to this, prior to renewing the session. Its implementation is
@@ -31,10 +38,12 @@ export const enum LifeCycleEventType {
   // on the same domain.
   SESSION_EXPIRED,
   SESSION_RENEWED,
-  PAGE_MAY_EXIT,
+  PREPARE_URGENT_FLUSH,
   RAW_RUM_EVENT_COLLECTED,
   RUM_EVENT_COLLECTED,
   RAW_ERROR_COLLECTED,
+  ACTION_STARTED,
+  DURATION_VITAL_STARTED,
 }
 
 // This is a workaround for an issue occurring when the Browser SDK is included in a TypeScript
@@ -48,9 +57,9 @@ export const enum LifeCycleEventType {
 // JavaScript).
 //
 // See issues:
-// * https://github.com/kubsense/kubsense-browser-sdk/issues/2208
 // * https://github.com/microsoft/TypeScript/issues/54152
 declare const LifeCycleEventTypeAsConst: {
+  ACTION_STARTED: LifeCycleEventType.ACTION_STARTED
   AUTO_ACTION_COMPLETED: LifeCycleEventType.AUTO_ACTION_COMPLETED
   BEFORE_VIEW_CREATED: LifeCycleEventType.BEFORE_VIEW_CREATED
   VIEW_CREATED: LifeCycleEventType.VIEW_CREATED
@@ -60,17 +69,20 @@ declare const LifeCycleEventTypeAsConst: {
   AFTER_VIEW_ENDED: LifeCycleEventType.AFTER_VIEW_ENDED
   REQUEST_STARTED: LifeCycleEventType.REQUEST_STARTED
   REQUEST_COMPLETED: LifeCycleEventType.REQUEST_COMPLETED
+  WEBSOCKET_COMPLETED: LifeCycleEventType.WEBSOCKET_COMPLETED
   SESSION_EXPIRED: LifeCycleEventType.SESSION_EXPIRED
   SESSION_RENEWED: LifeCycleEventType.SESSION_RENEWED
-  PAGE_MAY_EXIT: LifeCycleEventType.PAGE_MAY_EXIT
+  PREPARE_URGENT_FLUSH: LifeCycleEventType.PREPARE_URGENT_FLUSH
   RAW_RUM_EVENT_COLLECTED: LifeCycleEventType.RAW_RUM_EVENT_COLLECTED
   RUM_EVENT_COLLECTED: LifeCycleEventType.RUM_EVENT_COLLECTED
   RAW_ERROR_COLLECTED: LifeCycleEventType.RAW_ERROR_COLLECTED
+  DURATION_VITAL_STARTED: LifeCycleEventType.DURATION_VITAL_STARTED
 }
 
 // Note: this interface needs to be exported even if it is not used outside of this module, else TS
 // fails to build the rum-core package with error TS4058
 export interface LifeCycleEventMap {
+  [LifeCycleEventTypeAsConst.ACTION_STARTED]: TrackedEventData<ActionEventData>
   [LifeCycleEventTypeAsConst.AUTO_ACTION_COMPLETED]: AutoAction
   [LifeCycleEventTypeAsConst.BEFORE_VIEW_CREATED]: ViewCreatedEvent
   [LifeCycleEventTypeAsConst.VIEW_CREATED]: ViewCreatedEvent
@@ -80,21 +92,22 @@ export interface LifeCycleEventMap {
   [LifeCycleEventTypeAsConst.AFTER_VIEW_ENDED]: ViewEndedEvent
   [LifeCycleEventTypeAsConst.REQUEST_STARTED]: RequestStartEvent
   [LifeCycleEventTypeAsConst.REQUEST_COMPLETED]: RequestCompleteEvent
-  [LifeCycleEventTypeAsConst.SESSION_EXPIRED]: void
+  [LifeCycleEventTypeAsConst.WEBSOCKET_COMPLETED]: WebSocketCompleteEvent
+  [LifeCycleEventTypeAsConst.SESSION_EXPIRED]: SessionExpiredEvent
   [LifeCycleEventTypeAsConst.SESSION_RENEWED]: void
-  [LifeCycleEventTypeAsConst.PAGE_MAY_EXIT]: PageMayExitEvent
+  [LifeCycleEventTypeAsConst.PREPARE_URGENT_FLUSH]: UrgentFlushReason
   [LifeCycleEventTypeAsConst.RAW_RUM_EVENT_COLLECTED]: RawRumEventCollectedData
   [LifeCycleEventTypeAsConst.RUM_EVENT_COLLECTED]: AssembledRumEvent
   [LifeCycleEventTypeAsConst.RAW_ERROR_COLLECTED]: {
     error: RawError
     customerContext?: Context
   }
+  [LifeCycleEventTypeAsConst.DURATION_VITAL_STARTED]: DurationVitalStart
 }
 
 export interface RawRumEventCollectedData<E extends RawRumEvent = RawRumEvent> {
-  startTime: RelativeTime
+  startClocks: ClocksState
   duration?: Duration
-  customerContext?: Context
   rawRumEvent: E
   domainContext: RumEventDomainContext<E['type']>
 }

package/src/domain/limitModification.ts

@@ -1,12 +1,17 @@
-import { sanitize, deepClone, getType, objectEntries } from '@kubesense/kubesense-browser-core'
+import { sanitize, objectEntries } from '@kubesense/kubesense-browser-core'
 import type { Context } from '@kubesense/kubesense-browser-core'
+import { deepClone, getType } from '@kubesense/kubesense-js-core/util'
 
-export type ModifiableFieldPaths = Record<string, 'string' | 'object'>
+export type ModifiableFieldPaths = Record<string, 'string' | 'object' | 'array'>
 
 /**
  * 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).
+ *
+ * Modifications of the object are sanitized only if the field was actually changed by the modifier function (i.e., value is different).
+ * This ensures consistent SDK behavior regardless of whether limitModification is called.
+ * Only string fields are handled this way, object fields are sanitized regardless of whether the modifier function was called or not.
  */
 export function limitModification<T extends Context, Result>(
   object: T,
@@ -24,7 +29,12 @@ export function limitModification<T extends Context, Result>(
   return result
 }
 
-function setValueAtPath(object: unknown, clone: unknown, pathSegments: string[], fieldType: 'string' | 'object') {
+function setValueAtPath(
+  object: unknown,
+  clone: unknown,
+  pathSegments: string[],
+  fieldType: 'string' | 'object' | 'array'
+) {
   const [field, ...restPathSegments] = pathSegments
 
   if (field === '[]') {
@@ -50,14 +60,20 @@ function setNestedValue(
   object: Record<string, unknown>,
   field: string,
   value: unknown,
-  fieldType: 'string' | 'object'
+  fieldType: 'string' | 'object' | 'array'
 ) {
+  if (object[field] === value) {
+    return
+  }
+
   const newType = getType(value)
 
   if (newType === fieldType) {
     object[field] = sanitize(value)
   } else if (fieldType === 'object' && (newType === 'undefined' || newType === 'null')) {
     object[field] = {}
+  } else if (fieldType === 'array' && (newType === 'undefined' || newType === 'null')) {
+    object[field] = []
   }
 }
 

package/src/domain/longTask/longTaskCollection.ts

@@ -1,12 +1,6 @@
-import type { RelativeTime, ClocksState, Duration } from '@kubesense/kubesense-browser-core'
-import {
-  toServerDuration,
-  relativeToClocks,
-  generateUUID,
-  createValueHistory,
-  SESSION_TIME_OUT_DELAY,
-  addDuration,
-} from '@kubesense/kubesense-browser-core'
+import type { ClocksState } from '@kubesense/kubesense-js-core/time'
+import { toServerDuration, relativeToClocks } from '@kubesense/kubesense-js-core/time'
+import { generateUUID, buildDebugIdByUrl } from '@kubesense/kubesense-browser-core'
 import type { RawRumLongTaskEvent, RawRumLongAnimationFrameEvent } from '../../rawRumEvent.types'
 import { RumEventType, RumLongTaskEntryType } from '../../rawRumEvent.types'
 import type { LifeCycle } from '../lifeCycle'
@@ -23,28 +17,12 @@ import type {
 } from '../../browser/performanceObservable'
 import type { RumConfiguration } from '../configuration'
 
-export const LONG_TASK_ID_HISTORY_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY
-
-export interface LongTaskContext {
-  id: string
-  startClocks: ClocksState
-  duration: Duration
-  entryType: RumPerformanceEntryType.LONG_ANIMATION_FRAME | RumPerformanceEntryType.LONG_TASK
-}
-
-export interface LongTaskContexts {
-  findLongTasks: (startTime: RelativeTime) => LongTaskContext[]
-}
-
 export function startLongTaskCollection(lifeCycle: LifeCycle, configuration: RumConfiguration) {
-  const history = createValueHistory<LongTaskContext>({
-    expireDelay: LONG_TASK_ID_HISTORY_TIME_OUT_DELAY,
-  })
   const entryType = supportPerformanceTimingEvent(RumPerformanceEntryType.LONG_ANIMATION_FRAME)
     ? RumPerformanceEntryType.LONG_ANIMATION_FRAME
     : RumPerformanceEntryType.LONG_TASK
 
-  const subscription = createPerformanceObservable(configuration, {
+  const subscription = createPerformanceObservable({
     type: entryType,
     buffered: true,
   }).subscribe((entries) => {
@@ -54,39 +32,29 @@ export function startLongTaskCollection(lifeCycle: LifeCycle, configuration: Rum
       }
 
       const startClocks = relativeToClocks(entry.startTime)
-      const taskId = generateUUID()
-      const rawRumEvent = processEntry(entry, startClocks, taskId)
+      const rawRumEvent = processEntry(entry, startClocks)
 
       lifeCycle.notify(LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, {
         rawRumEvent,
-        startTime: startClocks.relative,
+        startClocks,
         duration: entry.duration,
         domainContext: { performanceEntry: entry },
       })
-
-      history.add({ id: taskId, startClocks, duration: entry.duration, entryType }, startClocks.relative)
-      history.closeActive(addDuration(startClocks.relative, entry.duration))
     }
   })
 
-  const longTaskContexts: LongTaskContexts = {
-    findLongTasks: (startTime: RelativeTime) => history.findAll(startTime),
-  }
-
   return {
-    stop: () => {
-      subscription.unsubscribe()
-      history.stop()
-    },
-    longTaskContexts,
+    stop: () => subscription.unsubscribe(),
   }
 }
 
 function processEntry(
   entry: RumPerformanceLongTaskTiming | RumPerformanceLongAnimationFrameTiming,
-  startClocks: ClocksState,
-  taskId: string
+  startClocks: ClocksState
 ): RawRumLongTaskEvent | RawRumLongAnimationFrameEvent {
+  const id = generateUUID()
+  const duration = toServerDuration(entry.duration)
+
   const baseEvent = {
     date: startClocks.timeStamp,
     type: RumEventType.LONG_TASK,
@@ -97,19 +65,22 @@ function processEntry(
     return {
       ...baseEvent,
       long_task: {
-        id: taskId,
+        id,
         entry_type: RumLongTaskEntryType.LONG_TASK,
-        duration: toServerDuration(entry.duration),
+        duration,
       },
     }
   }
+  const scriptUrls = entry.scripts.map((script) => script.sourceURL).filter((url): url is string => !!url)
+  const debugIdByUrl = buildDebugIdByUrl(scriptUrls)
 
   return {
     ...baseEvent,
+    _kubesense: { discarded: false, debug_ids: debugIdByUrl },
     long_task: {
-      id: taskId,
+      id,
       entry_type: RumLongTaskEntryType.LONG_ANIMATION_FRAME,
-      duration: toServerDuration(entry.duration),
+      duration,
       blocking_duration: toServerDuration(entry.blockingDuration),
       first_ui_event_timestamp: toServerDuration(entry.firstUIEventTimestamp),
       render_start: toServerDuration(entry.renderStart),