@kubesense/kubesense-browser-rum 1.8.0 → 2.0.0-beta.1

package/src/domain/record/trackers/trackMutation.ts

@@ -1,39 +1,15 @@
-import { monitor, noop } from '@kubesense/kubesense-browser-core'
-import type {
-  NodePrivacyLevelCache,
-  RumMutationRecord,
-  RumChildListMutationRecord,
-  RumCharacterDataMutationRecord,
-  RumAttributesMutationRecord,
-} from '@kubesense/kubesense-browser-rum-core'
-import { isNodeShadowHost, getMutationObserverConstructor, getParentNode, forEachChildNodes, getNodePrivacyLevel, getTextContent, NodePrivacyLevel } from '@kubesense/kubesense-browser-rum-core'
-import { IncrementalSource } from '../../../types'
-import type {
-  BrowserMutationData,
-  AddedNodeMutation,
-  AttributeMutation,
-  RemovedNodeMutation,
-  TextMutation,
-} from '../../../types'
+import { monitor } from '@kubesense/kubesense-js-core/monitor'
+import { noop } from '@kubesense/kubesense-browser-core'
+import { timeStampNow } from '@kubesense/kubesense-js-core/time'
+import type { RumMutationRecord } from '@kubesense/kubesense-browser-rum-core'
+import { getMutationObserverConstructor } from '@kubesense/kubesense-browser-rum-core'
 import type { RecordingScope } from '../recordingScope'
-import type { SerializationTransaction } from '../serialization'
-import {
-  getElementInputValue,
-  serializeAttribute,
-  serializeInTransaction,
-  serializeNode,
-  SerializationKind,
-} from '../serialization'
 import { createMutationBatch } from '../mutationBatch'
-import type { RemoveShadowRootCallBack } from '../shadowRootsController'
-import { assembleIncrementalSnapshot } from '../assembly'
-import type { NodeId, NodeWithSerializedNode } from '../nodeIds'
-import type { EmitRecordCallback, EmitStatsCallback } from '../record.types'
+import type { EmitRecordCallback, EmitResourceCallback, EmitStatsCallback } from '../record.types'
+import { serializeMutations } from '../serialization'
 import type { Tracker } from './tracker.types'
 
-type WithSerializedTarget<T> = T & { target: NodeWithSerializedNode }
-
-export type MutationTracker = Tracker & { flush: () => void }
+export type MutationTracker = Tracker & { flush: () => void; notifyContentMutated: () => void }
 
 /**
  * Buffers and aggregate mutations generated by a MutationObserver into MutationPayload
@@ -41,26 +17,27 @@ export type MutationTracker = Tracker & { flush: () => void }
 export function trackMutation(
   target: Node,
   emitRecord: EmitRecordCallback,
+  emitResource: EmitResourceCallback,
   emitStats: EmitStatsCallback,
   scope: RecordingScope
 ): MutationTracker {
   const MutationObserver = getMutationObserverConstructor()
   if (!MutationObserver) {
-    return { stop: noop, flush: noop }
+    return { stop: noop, flush: noop, notifyContentMutated: noop }
   }
 
   const mutationBatch = createMutationBatch((mutations) => {
-    serializeInTransaction(
-      SerializationKind.INCREMENTAL_SNAPSHOT,
+    serializeMutations(
+      timeStampNow(),
+      mutations.concat(observer.takeRecords() as RumMutationRecord[]),
       emitRecord,
+      emitResource,
       emitStats,
-      scope,
-      (transaction: SerializationTransaction) =>
-        processMutations(mutations.concat(observer.takeRecords() as RumMutationRecord[]), transaction)
+      scope
     )
   })
 
-  const observer = new MutationObserver(monitor(mutationBatch.addMutations) as (callback: RumMutationRecord[]) => void)
+  const observer = new MutationObserver(monitor(mutationBatch.addMutations))
 
   observer.observe(target, {
     attributeOldValue: true,
@@ -79,321 +56,6 @@ export function trackMutation(
     flush: () => {
       mutationBatch.flush()
     },
+    notifyContentMutated: mutationBatch.notifyContentMutated,
   }
 }
-
-function processMutations(mutations: RumMutationRecord[], transaction: SerializationTransaction): void {
-  const nodePrivacyLevelCache: NodePrivacyLevelCache = new Map()
-
-  mutations
-    .filter((mutation): mutation is RumChildListMutationRecord => mutation.type === 'childList')
-    .forEach((mutation) => {
-      mutation.removedNodes.forEach((removedNode) => {
-        traverseRemovedShadowDom(removedNode, transaction.scope.shadowRootsController.removeShadowRoot)
-      })
-    })
-
-  // Discard any mutation with a 'target' node that:
-  // * isn't injected in the current document or isn't known/serialized yet: those nodes are likely
-  // part of a mutation occurring in a parent Node
-  // * should be hidden or ignored
-  const filteredMutations = mutations.filter(
-    (mutation): mutation is WithSerializedTarget<RumMutationRecord> =>
-      mutation.target.isConnected &&
-      transaction.scope.nodeIds.areAssignedForNodeAndAncestors(mutation.target) &&
-      getNodePrivacyLevel(
-        mutation.target,
-        transaction.scope.configuration.defaultPrivacyLevel,
-        nodePrivacyLevelCache
-      ) !== NodePrivacyLevel.HIDDEN
-  )
-
-  const { adds, removes, hasBeenSerialized } = processChildListMutations(
-    filteredMutations.filter(
-      (mutation): mutation is WithSerializedTarget<RumChildListMutationRecord> => mutation.type === 'childList'
-    ),
-    nodePrivacyLevelCache,
-    transaction
-  )
-
-  const texts = processCharacterDataMutations(
-    filteredMutations.filter(
-      (mutation): mutation is WithSerializedTarget<RumCharacterDataMutationRecord> =>
-        mutation.type === 'characterData' && !hasBeenSerialized(mutation.target)
-    ),
-    nodePrivacyLevelCache,
-    transaction
-  )
-
-  const attributes = processAttributesMutations(
-    filteredMutations.filter(
-      (mutation): mutation is WithSerializedTarget<RumAttributesMutationRecord> =>
-        mutation.type === 'attributes' && !hasBeenSerialized(mutation.target)
-    ),
-    nodePrivacyLevelCache,
-    transaction
-  )
-
-  if (!texts.length && !attributes.length && !removes.length && !adds.length) {
-    return
-  }
-
-  transaction.add(
-    assembleIncrementalSnapshot<BrowserMutationData>(IncrementalSource.Mutation, {
-      adds,
-      removes,
-      texts,
-      attributes,
-    })
-  )
-}
-
-function processChildListMutations(
-  mutations: Array<WithSerializedTarget<RumChildListMutationRecord>>,
-  nodePrivacyLevelCache: NodePrivacyLevelCache,
-  transaction: SerializationTransaction
-) {
-  // First, we iterate over mutations to collect:
-  //
-  // * nodes that have been added in the document and not removed by a subsequent mutation
-  // * nodes that have been removed from the document but were not added in a previous mutation
-  //
-  // For this second category, we also collect their previous parent (mutation.target) because we'll
-  // need it to emit a 'remove' mutation.
-  //
-  // Those two categories may overlap: if a node moved from a position to another, it is reported as
-  // two mutation records, one with a "removedNodes" and the other with "addedNodes". In this case,
-  // the node will be in both sets.
-  const addedAndMovedNodes = new Set<Node>()
-  const removedNodes = new Map<Node, NodeWithSerializedNode>()
-  for (const mutation of mutations) {
-    mutation.addedNodes.forEach((node) => {
-      addedAndMovedNodes.add(node)
-    })
-    mutation.removedNodes.forEach((node) => {
-      if (!addedAndMovedNodes.has(node)) {
-        removedNodes.set(node, mutation.target)
-      }
-      addedAndMovedNodes.delete(node)
-    })
-  }
-
-  // Then, we sort nodes that are still in the document by topological order, for two reasons:
-  //
-  // * We will serialize each added nodes with their descendants. We don't want to serialize a node
-  // twice, so we need to iterate over the parent nodes first and skip any node that is contained in
-  // a precedent node.
-  //
-  // * To emit "add" mutations, we need references to the parent and potential next sibling of each
-  // added node. So we need to iterate over the parent nodes first, and when multiple nodes are
-  // siblings, we want to iterate from last to first. This will ensure that any "next" node is
-  // already serialized and have an id.
-  const sortedAddedAndMovedNodes = Array.from(addedAndMovedNodes)
-  sortAddedAndMovedNodes(sortedAddedAndMovedNodes)
-
-  // Then, we iterate over our sorted node sets to emit mutations. We collect the newly serialized
-  // node ids in a set to be able to skip subsequent related mutations.
-  transaction.serializedNodeIds = new Set<NodeId>()
-
-  const addedNodeMutations: AddedNodeMutation[] = []
-  for (const node of sortedAddedAndMovedNodes) {
-    if (hasBeenSerialized(node)) {
-      continue
-    }
-
-    const parentNodePrivacyLevel = getNodePrivacyLevel(
-      node.parentNode!,
-      transaction.scope.configuration.defaultPrivacyLevel,
-      nodePrivacyLevelCache
-    )
-    if (parentNodePrivacyLevel === NodePrivacyLevel.HIDDEN || parentNodePrivacyLevel === NodePrivacyLevel.IGNORE) {
-      continue
-    }
-
-    const serializedNode = serializeNode(node, parentNodePrivacyLevel, transaction)
-    if (!serializedNode) {
-      continue
-    }
-
-    const parentNode = getParentNode(node)!
-    addedNodeMutations.push({
-      nextId: getNextSibling(node),
-      parentId: transaction.scope.nodeIds.get(parentNode)!,
-      node: serializedNode,
-    })
-  }
-  // Finally, we emit remove mutations.
-  const removedNodeMutations: RemovedNodeMutation[] = []
-  removedNodes.forEach((parent, node) => {
-    const parentId = transaction.scope.nodeIds.get(parent)
-    const id = transaction.scope.nodeIds.get(node)
-    if (parentId !== undefined && id !== undefined) {
-      removedNodeMutations.push({ parentId, id })
-    }
-  })
-
-  return { adds: addedNodeMutations, removes: removedNodeMutations, hasBeenSerialized }
-
-  function hasBeenSerialized(node: Node) {
-    const id = transaction.scope.nodeIds.get(node)
-    return id !== undefined && transaction.serializedNodeIds?.has(id)
-  }
-
-  function getNextSibling(node: Node): null | number {
-    let nextSibling = node.nextSibling
-    while (nextSibling) {
-      const id = transaction.scope.nodeIds.get(nextSibling)
-      if (id !== undefined) {
-        return id
-      }
-      nextSibling = nextSibling.nextSibling
-    }
-
-    return null
-  }
-}
-
-function processCharacterDataMutations(
-  mutations: Array<WithSerializedTarget<RumCharacterDataMutationRecord>>,
-  nodePrivacyLevelCache: NodePrivacyLevelCache,
-  transaction: SerializationTransaction
-) {
-  const textMutations: TextMutation[] = []
-
-  // Deduplicate mutations based on their target node
-  const handledNodes = new Set<Node>()
-  const filteredMutations = mutations.filter((mutation) => {
-    if (handledNodes.has(mutation.target)) {
-      return false
-    }
-    handledNodes.add(mutation.target)
-    return true
-  })
-
-  // Emit mutations
-  for (const mutation of filteredMutations) {
-    const value = mutation.target.textContent
-    if (value === mutation.oldValue) {
-      continue
-    }
-
-    const id = transaction.scope.nodeIds.get(mutation.target)
-    if (id === undefined) {
-      continue
-    }
-
-    const parentNodePrivacyLevel = getNodePrivacyLevel(
-      getParentNode(mutation.target)!,
-      transaction.scope.configuration.defaultPrivacyLevel,
-      nodePrivacyLevelCache
-    )
-    if (parentNodePrivacyLevel === NodePrivacyLevel.HIDDEN || parentNodePrivacyLevel === NodePrivacyLevel.IGNORE) {
-      continue
-    }
-
-    textMutations.push({
-      id,
-      value: getTextContent(mutation.target, parentNodePrivacyLevel) ?? null,
-    })
-  }
-
-  return textMutations
-}
-
-function processAttributesMutations(
-  mutations: Array<WithSerializedTarget<RumAttributesMutationRecord>>,
-  nodePrivacyLevelCache: NodePrivacyLevelCache,
-  transaction: SerializationTransaction
-) {
-  const attributeMutations: AttributeMutation[] = []
-
-  // Deduplicate mutations based on their target node and changed attribute
-  const handledElements = new Map<Element, Set<string>>()
-  const filteredMutations = mutations.filter((mutation) => {
-    const handledAttributes = handledElements.get(mutation.target)
-    if (handledAttributes && handledAttributes.has(mutation.attributeName!)) {
-      return false
-    }
-    if (!handledAttributes) {
-      handledElements.set(mutation.target, new Set([mutation.attributeName!]))
-    } else {
-      handledAttributes.add(mutation.attributeName!)
-    }
-    return true
-  })
-
-  // Emit mutations
-  const emittedMutations = new Map<Element, AttributeMutation>()
-  for (const mutation of filteredMutations) {
-    const uncensoredValue = mutation.target.getAttribute(mutation.attributeName!)
-    if (uncensoredValue === mutation.oldValue) {
-      continue
-    }
-
-    const id = transaction.scope.nodeIds.get(mutation.target)
-    if (id === undefined) {
-      continue
-    }
-
-    const privacyLevel = getNodePrivacyLevel(
-      mutation.target,
-      transaction.scope.configuration.defaultPrivacyLevel,
-      nodePrivacyLevelCache
-    )
-    const attributeValue = serializeAttribute(
-      mutation.target,
-      privacyLevel,
-      mutation.attributeName!,
-      transaction.scope.configuration
-    )
-
-    let transformedValue: string | null
-    if (mutation.attributeName === 'value') {
-      const inputValue = getElementInputValue(mutation.target, privacyLevel)
-      if (inputValue === undefined) {
-        continue
-      }
-      transformedValue = inputValue
-    } else if (typeof attributeValue === 'string') {
-      transformedValue = attributeValue
-    } else {
-      transformedValue = null
-    }
-
-    let emittedMutation = emittedMutations.get(mutation.target)
-    if (!emittedMutation) {
-      emittedMutation = { id, attributes: {} }
-      attributeMutations.push(emittedMutation)
-      emittedMutations.set(mutation.target, emittedMutation)
-    }
-
-    emittedMutation.attributes[mutation.attributeName!] = transformedValue
-  }
-
-  return attributeMutations
-}
-
-export function sortAddedAndMovedNodes(nodes: Node[]) {
-  nodes.sort((a, b) => {
-    const position = a.compareDocumentPosition(b)
-    /* eslint-disable no-bitwise */
-    if (position & Node.DOCUMENT_POSITION_CONTAINED_BY) {
-      return -1
-    } else if (position & Node.DOCUMENT_POSITION_CONTAINS) {
-      return 1
-    } else if (position & Node.DOCUMENT_POSITION_FOLLOWING) {
-      return 1
-    } else if (position & Node.DOCUMENT_POSITION_PRECEDING) {
-      return -1
-    }
-    /* eslint-enable no-bitwise */
-    return 0
-  })
-}
-
-function traverseRemovedShadowDom(removedNode: Node, shadowDomRemovedCallback: RemoveShadowRootCallBack) {
-  if (isNodeShadowHost(removedNode)) {
-    shadowDomRemovedCallback(removedNode.shadowRoot)
-  }
-  forEachChildNodes(removedNode, (childNode) => traverseRemovedShadowDom(childNode, shadowDomRemovedCallback))
-}

package/src/domain/record/trackers/trackScroll.ts

@@ -47,7 +47,7 @@ export function trackScroll(
     )
   }, SCROLL_OBSERVER_THRESHOLD)
 
-  const { stop: removeListener } = addEventListener(scope.configuration, target, DOM_EVENT.SCROLL, updatePosition, {
+  const { stop: removeListener } = addEventListener(target, DOM_EVENT.SCROLL, updatePosition, {
     capture: true,
     passive: true,
   })

package/src/domain/record/trackers/trackStyleSheet.ts

@@ -13,7 +13,7 @@ export function trackStyleSheet(
   scope: RecordingScope
 ): Tracker {
   function checkStyleSheetAndCallback(styleSheet: CSSStyleSheet | null, callback: (id: number) => void): void {
-    if (!styleSheet || !styleSheet.ownerNode) {
+    if (!styleSheet?.ownerNode) {
       return
     }
     const id = scope.nodeIds.get(styleSheet.ownerNode)

package/src/domain/record/trackers/trackViewEnd.ts

@@ -1,4 +1,4 @@
-import { timeStampNow } from '@kubesense/kubesense-browser-core'
+import { timeStampNow } from '@kubesense/kubesense-js-core/time'
 import type { LifeCycle } from '@kubesense/kubesense-browser-rum-core'
 import { LifeCycleEventType } from '@kubesense/kubesense-browser-rum-core'
 import type { ViewEndRecord } from '../../../types'

package/src/domain/record/trackers/trackViewportResize.ts

@@ -1,4 +1,5 @@
-import { throttle, DOM_EVENT, addEventListeners, timeStampNow, noop } from '@kubesense/kubesense-browser-core'
+import { throttle, DOM_EVENT, addEventListeners, noop } from '@kubesense/kubesense-browser-core'
+import { timeStampNow } from '@kubesense/kubesense-js-core/time'
 import type { ViewportDimension } from '@kubesense/kubesense-browser-rum-core'
 import { initViewportObservable } from '@kubesense/kubesense-browser-rum-core'
 import { IncrementalSource, RecordType } from '../../../types'
@@ -6,20 +7,14 @@ import type { BrowserIncrementalSnapshotRecord, ViewportResizeData, VisualViewpo
 import { getVisualViewport } from '../viewports'
 import { assembleIncrementalSnapshot } from '../assembly'
 import type { EmitRecordCallback } from '../record.types'
-import type { RecordingScope } from '../recordingScope'
 import type { Tracker } from './tracker.types'
 
 const VISUAL_VIEWPORT_OBSERVER_THRESHOLD = 200
 
-export function trackViewportResize(
-  emitRecord: EmitRecordCallback<BrowserIncrementalSnapshotRecord>,
-  scope: RecordingScope
-): Tracker {
-  const viewportResizeSubscription = initViewportObservable(scope.configuration).subscribe(
-    (data: ViewportDimension) => {
-      emitRecord(assembleIncrementalSnapshot<ViewportResizeData>(IncrementalSource.ViewportResize, data))
-    }
-  )
+export function trackViewportResize(emitRecord: EmitRecordCallback<BrowserIncrementalSnapshotRecord>): Tracker {
+  const viewportResizeSubscription = initViewportObservable().subscribe((data: ViewportDimension) => {
+    emitRecord(assembleIncrementalSnapshot<ViewportResizeData>(IncrementalSource.ViewportResize, data))
+  })
 
   return {
     stop: () => {
@@ -28,10 +23,7 @@ export function trackViewportResize(
   }
 }
 
-export function trackVisualViewportResize(
-  emitRecord: EmitRecordCallback<VisualViewportRecord>,
-  scope: RecordingScope
-): Tracker {
+export function trackVisualViewportResize(emitRecord: EmitRecordCallback<VisualViewportRecord>): Tracker {
   const visualViewport = window.visualViewport
   if (!visualViewport) {
     return { stop: noop }
@@ -50,7 +42,6 @@ export function trackVisualViewportResize(
     }
   )
   const { stop: removeListener } = addEventListeners(
-    scope.configuration,
     visualViewport,
     [DOM_EVENT.RESIZE, DOM_EVENT.SCROLL],
     updateDimension,

package/src/domain/record/trackers/tracker.types.ts

@@ -1,3 +1,3 @@
 export interface Tracker {
-    stop: () => void
+  stop: () => void
 }

package/src/domain/replayStats.ts

@@ -15,6 +15,10 @@ export function addRecord(viewId: string) {
   getOrCreateReplayStats(viewId).records_count += 1
 }
 
+export function addResource(viewId: string) {
+  getOrCreateReplayStats(viewId).resources_count += 1
+}
+
 export function addWroteData(viewId: string, additionalBytesCount: number) {
   getOrCreateReplayStats(viewId).segments_total_raw_size += additionalBytesCount
 }
@@ -38,6 +42,7 @@ function getOrCreateReplayStats(viewId: string) {
   } else {
     replayStats = {
       records_count: 0,
+      resources_count: 0,
       segments_count: 0,
       segments_total_raw_size: 0,
     }

package/src/domain/scriptLoadingError.ts

@@ -1,4 +1,5 @@
-import { addTelemetryError, display, DOCS_ORIGIN } from '@kubesense/kubesense-browser-core'
+import { DOCS_ORIGIN } from '@kubesense/kubesense-js-core/util'
+import { addTelemetryError, display } from '@kubesense/kubesense-browser-core'
 
 export function reportScriptLoadingError({
   configuredUrl,

package/src/domain/segmentCollection/buildResourcePayload.ts

@@ -0,0 +1,20 @@
+import type { Payload } from '@kubesense/kubesense-browser-core'
+
+export type ResourcePayload = Payload & {
+  hash: string
+}
+
+export function buildResourcePayload(hash: string, content: Blob, application: string): ResourcePayload {
+  const formData = new FormData()
+
+  formData.append('image', content, hash)
+
+  const event = { application: { id: application }, type: 'resource' }
+  formData.append('event', new Blob([JSON.stringify(event)], { type: 'application/json' }))
+
+  return {
+    data: formData,
+    bytesCount: content.size,
+    hash,
+  }
+}

package/src/domain/segmentCollection/index.ts

@@ -1,4 +1,7 @@
 export { startSegmentCollection, setSegmentBytesLimit } from './segmentCollection'
 export { SEGMENT_BYTES_LIMIT } from './segmentCollection'
 export type { BrowserSegmentMetadataAndSegmentSizes, ReplayPayload } from './buildReplayPayload'
+export type { ResourcePayload } from './buildResourcePayload'
 export { startSegmentTelemetry } from './startSegmentTelemetry'
+export { startDroppedSegmentRecovery } from './startDroppedSegmentRecovery'
+export { startReplayResourceCollection } from './replayResourceCollection'

package/src/domain/segmentCollection/replayResourceCollection.ts

@@ -0,0 +1,79 @@
+import { isPageExitReason, PageExitReason } from '@kubesense/kubesense-browser-core'
+import type { HttpRequest } from '@kubesense/kubesense-browser-core'
+import type { LifeCycle } from '@kubesense/kubesense-browser-rum-core'
+import { LifeCycleEventType } from '@kubesense/kubesense-browser-rum-core'
+import type { EmitResourceCallback } from '../record'
+import { buildResourcePayload } from './buildResourcePayload'
+import type { ResourcePayload } from './buildResourcePayload'
+
+interface ReplayResourceCollection {
+  emitResource: EmitResourceCallback
+  stop(this: void): void
+}
+
+interface PendingResource {
+  payload: ResourcePayload
+  onDiscards: Set<() => void>
+}
+
+export function startReplayResourceCollection(
+  applicationId: string,
+  lifeCycle: LifeCycle,
+  httpRequest: HttpRequest<ResourcePayload>
+): ReplayResourceCollection {
+  const uploadedHashes = new Set<string>()
+  const pendingResourcesByHash = new Map<string, PendingResource>()
+
+  const { unsubscribe: unsubscribeRequest } = httpRequest.observable.subscribe((event) => {
+    if (event.type === 'success') {
+      const resource = pendingResourcesByHash.get(event.payload.hash)
+      pendingResourcesByHash.delete(event.payload.hash)
+      if (resource) {
+        resource.onDiscards.clear()
+      }
+    } else if (event.type === 'queue-full' || event.type === 'dropped') {
+      // Discarded — the queue was full, or the upload failed for good (see the retries in
+      // kubesenseRecorder). Forgetting the hash lets the canvas be captured and uploaded again.
+      const resource = pendingResourcesByHash.get(event.payload.hash)
+      pendingResourcesByHash.delete(event.payload.hash)
+      if (resource) {
+        uploadedHashes.delete(event.payload.hash)
+        resource.onDiscards.forEach((onDiscard) => onDiscard())
+      }
+    }
+  })
+
+  const { unsubscribe: unsubscribePageMayExit } = lifeCycle.subscribe(
+    LifeCycleEventType.PREPARE_URGENT_FLUSH,
+    (reason) => {
+      if (isPageExitReason(reason) && reason !== PageExitReason.HIDDEN) {
+        pendingResourcesByHash.forEach(({ payload }) => httpRequest.sendOnExit(payload))
+      }
+    }
+  )
+
+  return {
+    emitResource: (hash, content, onDiscard) => {
+      if (uploadedHashes.has(hash)) {
+        if (onDiscard) {
+          pendingResourcesByHash.get(hash)?.onDiscards.add(onDiscard)
+        }
+        return
+      }
+      uploadedHashes.add(hash)
+      const payload = buildResourcePayload(hash, content, applicationId)
+      const resource = { payload, onDiscards: new Set<() => void>() }
+      if (onDiscard) {
+        resource.onDiscards.add(onDiscard)
+      }
+      pendingResourcesByHash.set(hash, resource)
+      httpRequest.send(payload)
+    },
+    stop: () => {
+      unsubscribeRequest()
+      unsubscribePageMayExit()
+      pendingResourcesByHash.clear()
+      uploadedHashes.clear()
+    },
+  }
+}

package/src/domain/segmentCollection/segment.ts

@@ -49,7 +49,8 @@ export function createSegment({
     metadata.start = Math.min(metadata.start, record.timestamp)
     metadata.end = Math.max(metadata.end, record.timestamp)
     metadata.records_count += 1
-    metadata.has_full_snapshot ||= record.type === RecordType.FullSnapshot
+    metadata.has_full_snapshot ||=
+      record.type === RecordType.FullSnapshot || (record.type === RecordType.Change && metadata.index_in_view === 0)
 
     const prefix = encoder.isEmpty ? '{"records":[' : ','
     encoder.write(prefix + JSON.stringify(record), (additionalEncodedBytesCount) => {