@kubesense/kubesense-browser-rum-core 1.0.0

package/src/domain/resource/resourceUtils.ts

@@ -0,0 +1,355 @@
+import type { Duration, RelativeTime } from '@kubesense/kubesense-browser-core'
+import {
+  elapsed,
+  getPathName,
+  isValidUrl,
+  buildUrl,
+  matchList,
+  ResourceType,
+  toServerDuration,
+  isIntakeUrl,
+  isExperimentalFeatureEnabled,
+  ExperimentalFeature,
+} from '@kubesense/kubesense-browser-core'
+import type { MatchOption } from '@kubesense/kubesense-browser-core'
+
+import type { RumPerformanceResourceTiming } from '../../browser/performanceObservable'
+
+import type { ResourceEntryDetailsElement, DeliveryType } from '../../rawRumEvent.types'
+
+export interface ResourceEntryDetails {
+  worker?: ResourceEntryDetailsElement
+  redirect?: ResourceEntryDetailsElement
+  dns?: ResourceEntryDetailsElement
+  connect?: ResourceEntryDetailsElement
+  ssl?: ResourceEntryDetailsElement
+  first_byte?: ResourceEntryDetailsElement
+  download?: ResourceEntryDetailsElement
+}
+
+export const FAKE_INITIAL_DOCUMENT = 'initial_document'
+
+const RESOURCE_TYPES: Array<[ResourceType, (initiatorType: string, path: string) => boolean]> = [
+  [ResourceType.DOCUMENT, (initiatorType: string) => FAKE_INITIAL_DOCUMENT === initiatorType],
+  [ResourceType.XHR, (initiatorType: string) => 'xmlhttprequest' === initiatorType],
+  [ResourceType.FETCH, (initiatorType: string) => 'fetch' === initiatorType],
+  [ResourceType.BEACON, (initiatorType: string) => 'beacon' === initiatorType],
+  [ResourceType.CSS, (_: string, path: string) => /\.css$/i.test(path)],
+  [ResourceType.JS, (_: string, path: string) => /\.js$/i.test(path)],
+  [
+    ResourceType.IMAGE,
+    (initiatorType: string, path: string) =>
+      ['image', 'img', 'icon'].includes(initiatorType) || /\.(gif|jpg|jpeg|tiff|png|svg|ico)$/i.exec(path) !== null,
+  ],
+  [ResourceType.FONT, (_: string, path: string) => /\.(woff|eot|woff2|ttf)$/i.exec(path) !== null],
+  [
+    ResourceType.MEDIA,
+    (initiatorType: string, path: string) =>
+      ['audio', 'video'].includes(initiatorType) || /\.(mp3|mp4)$/i.exec(path) !== null,
+  ],
+]
+
+export function computeResourceEntryType(entry: RumPerformanceResourceTiming) {
+  const url = entry.name
+  if (!isValidUrl(url)) {
+    return ResourceType.OTHER
+  }
+  const path = getPathName(url)
+  for (const [type, isType] of RESOURCE_TYPES) {
+    if (isType(entry.initiatorType, path)) {
+      return type
+    }
+  }
+  return ResourceType.OTHER
+}
+
+function areInOrder(...numbers: number[]) {
+  for (let i = 1; i < numbers.length; i += 1) {
+    if (numbers[i - 1] > numbers[i]) {
+      return false
+    }
+  }
+  return true
+}
+
+export function isResourceEntryRequestType(entry: RumPerformanceResourceTiming) {
+  return entry.initiatorType === 'xmlhttprequest' || entry.initiatorType === 'fetch'
+}
+
+export function computeResourceEntryDuration(entry: RumPerformanceResourceTiming): Duration {
+  const { duration, startTime, responseEnd } = entry
+
+  // Safari duration is always 0 on timings blocked by cross origin policies.
+  if (duration === 0 && startTime < responseEnd) {
+    return elapsed(startTime, responseEnd)
+  }
+
+  return duration
+}
+
+export function computeResourceEntryDetails(entry: RumPerformanceResourceTiming): ResourceEntryDetails | undefined {
+  if (!hasValidResourceEntryTimings(entry)) {
+    return undefined
+  }
+  const {
+    startTime,
+    fetchStart,
+    workerStart,
+    redirectStart,
+    redirectEnd,
+    domainLookupStart,
+    domainLookupEnd,
+    connectStart,
+    secureConnectionStart,
+    connectEnd,
+    requestStart,
+    responseStart,
+    responseEnd,
+  } = entry
+
+  const details: ResourceEntryDetails = {
+    download: formatTiming(startTime, responseStart, responseEnd),
+    first_byte: formatTiming(startTime, requestStart, responseStart),
+  }
+
+  // Make sure a worker processing time is recorded
+  if (0 < workerStart && workerStart < fetchStart) {
+    details.worker = formatTiming(startTime, workerStart, fetchStart)
+  }
+
+  // Make sure a connection occurred
+  if (fetchStart < connectEnd) {
+    details.connect = formatTiming(startTime, connectStart, connectEnd)
+
+    // Make sure a secure connection occurred
+    if (connectStart <= secureConnectionStart && secureConnectionStart <= connectEnd) {
+      details.ssl = formatTiming(startTime, secureConnectionStart, connectEnd)
+    }
+  }
+
+  // Make sure a domain lookup occurred
+  if (fetchStart < domainLookupEnd) {
+    details.dns = formatTiming(startTime, domainLookupStart, domainLookupEnd)
+  }
+
+  // Make sure a redirection occurred
+  if (startTime < redirectEnd) {
+    details.redirect = formatTiming(startTime, redirectStart, redirectEnd)
+  }
+
+  return details
+}
+
+/**
+ * Entries with negative duration are unexpected and should be dismissed. The intake will ignore RUM
+ * Resource events with negative durations anyway.
+ * Since Chromium 128, more entries have unexpected negative durations, see
+ * https://issues.chromium.org/issues/363031537
+ */
+export function hasValidResourceEntryDuration(entry: RumPerformanceResourceTiming) {
+  return entry.duration >= 0
+}
+
+export function hasValidResourceEntryTimings(entry: RumPerformanceResourceTiming) {
+  // Ensure timings are in the right order. On top of filtering out potential invalid
+  // RumPerformanceResourceTiming, it will ignore entries from requests where timings cannot be
+  // collected, for example cross origin requests without a "Timing-Allow-Origin" header allowing
+  // it.
+  const areCommonTimingsInOrder = areInOrder(
+    entry.startTime,
+    entry.fetchStart,
+    entry.domainLookupStart,
+    entry.domainLookupEnd,
+    entry.connectStart,
+    entry.connectEnd,
+    entry.requestStart,
+    entry.responseStart,
+    entry.responseEnd
+  )
+
+  const areRedirectionTimingsInOrder = hasRedirection(entry)
+    ? areInOrder(entry.startTime, entry.redirectStart, entry.redirectEnd, entry.fetchStart)
+    : true
+
+  return areCommonTimingsInOrder && areRedirectionTimingsInOrder
+}
+
+function hasRedirection(entry: RumPerformanceResourceTiming) {
+  return entry.redirectEnd > entry.startTime
+}
+function formatTiming(origin: RelativeTime, start: RelativeTime, end: RelativeTime) {
+  if (origin <= start && start <= end) {
+    return {
+      duration: toServerDuration(elapsed(start, end)),
+      start: toServerDuration(elapsed(origin, start)),
+    }
+  }
+}
+
+/**
+ * The 'nextHopProtocol' is an empty string for cross-origin resources without CORS headers,
+ * meaning the protocol is unknown, and we shouldn't report it.
+ * https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming/nextHopProtocol#cross-origin_resources
+ */
+export function computeResourceEntryProtocol(entry: RumPerformanceResourceTiming) {
+  return entry.nextHopProtocol === '' ? undefined : entry.nextHopProtocol
+}
+
+/**
+ * Handles the 'deliveryType' property to distinguish between supported values ('cache', 'navigational-prefetch'),
+ * undefined (unsupported in some browsers), and other cases ('other' for unknown or unrecognized values).
+ * see: https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming/deliveryType
+ */
+export function computeResourceEntryDeliveryType(entry: RumPerformanceResourceTiming): DeliveryType | undefined {
+  return entry.deliveryType === '' ? 'other' : entry.deliveryType
+}
+
+export function computeResourceEntrySize(entry: RumPerformanceResourceTiming) {
+  const { encodedBodySize, decodedBodySize, transferSize } = entry
+
+  // Report sizes when:
+  // 1. Timing data is valid (same-origin, non-cached) — timings in order confirms sizes are real
+  // 2. Body sizes are non-zero even without valid timings — happens for memory/disk-cached
+  //    resources where browsers zero out responseStart but still expose body sizes
+  //
+  // We skip reporting when all sizes are 0 AND timings are invalid (cross-origin resources
+  // where the browser zeros everything out as a security restriction).
+  if (hasValidResourceEntryTimings(entry) || (decodedBodySize ?? 0) > 0 || (encodedBodySize ?? 0) > 0) {
+    return {
+      size: decodedBodySize,
+      encoded_body_size: encodedBodySize,
+      decoded_body_size: decodedBodySize,
+      transfer_size: transferSize,
+    }
+  }
+  return {
+    size: undefined,
+    encoded_body_size: undefined,
+    decoded_body_size: undefined,
+    transfer_size: undefined,
+  }
+}
+
+export function isAllowedRequestUrl(url: string) {
+  return url && (!isIntakeUrl(url) || isExperimentalFeatureEnabled(ExperimentalFeature.TRACK_INTAKE_REQUESTS))
+}
+
+type ProviderType =
+  | 'ad'
+  | 'advertising'
+  | 'analytics'
+  | 'cdn'
+  | 'content'
+  | 'customer-success'
+  | 'first party'
+  | 'hosting'
+  | 'marketing'
+  | 'other'
+  | 'social'
+  | 'tag-manager'
+  | 'utility'
+  | 'video'
+
+interface KnownProvider {
+  domains: string[]
+  name: string
+  type: ProviderType
+}
+
+const KNOWN_PROVIDERS: KnownProvider[] = [
+  // Analytics
+  { domains: ['google-analytics.com', 'analytics.google.com'], name: 'Google Analytics', type: 'analytics' },
+  { domains: ['segment.com', 'segment.io', 'cdn.segment.com'], name: 'Segment', type: 'analytics' },
+  { domains: ['amplitude.com'], name: 'Amplitude', type: 'analytics' },
+  { domains: ['mixpanel.com'], name: 'Mixpanel', type: 'analytics' },
+  { domains: ['hotjar.com'], name: 'Hotjar', type: 'analytics' },
+  { domains: ['fullstory.com'], name: 'FullStory', type: 'analytics' },
+  { domains: ['heap.io'], name: 'Heap', type: 'analytics' },
+  // Tag Manager
+  { domains: ['googletagmanager.com'], name: 'Google Tag Manager', type: 'tag-manager' },
+  { domains: ['tealiumiq.com'], name: 'Tealium', type: 'tag-manager' },
+  // CDN
+  { domains: ['cloudfront.net'], name: 'Amazon CloudFront', type: 'cdn' },
+  { domains: ['fastly.net'], name: 'Fastly', type: 'cdn' },
+  { domains: ['akamaiedge.net', 'akamaistream.net', 'akamai.net'], name: 'Akamai', type: 'cdn' },
+  { domains: ['jsdelivr.net'], name: 'jsDelivr', type: 'cdn' },
+  { domains: ['unpkg.com'], name: 'unpkg', type: 'cdn' },
+  { domains: ['bootstrapcdn.com'], name: 'Bootstrap CDN', type: 'cdn' },
+  // Advertising
+  { domains: ['doubleclick.net'], name: 'Google DoubleClick', type: 'advertising' },
+  { domains: ['googlesyndication.com'], name: 'Google AdSense', type: 'advertising' },
+  { domains: ['adnxs.com'], name: 'AppNexus', type: 'advertising' },
+  { domains: ['criteo.com', 'criteo.net'], name: 'Criteo', type: 'advertising' },
+  // Social
+  { domains: ['facebook.com', 'fbcdn.net', 'connect.facebook.net'], name: 'Facebook', type: 'social' },
+  { domains: ['twitter.com', 'twimg.com', 'platform.twitter.com'], name: 'Twitter', type: 'social' },
+  { domains: ['linkedin.com'], name: 'LinkedIn', type: 'social' },
+  { domains: ['instagram.com', 'cdninstagram.com'], name: 'Instagram', type: 'social' },
+  { domains: ['pinterest.com'], name: 'Pinterest', type: 'social' },
+  // Video
+  { domains: ['youtube.com', 'youtu.be', 'ytimg.com', 'googlevideo.com'], name: 'YouTube', type: 'video' },
+  { domains: ['vimeo.com', 'vimeocdn.com'], name: 'Vimeo', type: 'video' },
+  { domains: ['wistia.com'], name: 'Wistia', type: 'video' },
+  // Marketing
+  { domains: ['hubspot.com', 'hs-scripts.com', 'hsforms.com'], name: 'HubSpot', type: 'marketing' },
+  { domains: ['marketo.com', 'mktoresp.com'], name: 'Marketo', type: 'marketing' },
+  { domains: ['mailchimp.com'], name: 'Mailchimp', type: 'marketing' },
+  // Customer Success
+  { domains: ['intercom.io', 'intercomcdn.com'], name: 'Intercom', type: 'customer-success' },
+  { domains: ['zendesk.com', 'zdassets.com'], name: 'Zendesk', type: 'customer-success' },
+  // Utility
+  { domains: ['stripe.com', 'js.stripe.com'], name: 'Stripe', type: 'utility' },
+  { domains: ['code.jquery.com'], name: 'jQuery', type: 'utility' },
+  { domains: ['recaptcha.net'], name: 'reCAPTCHA', type: 'utility' },
+]
+
+export function computeResourceProvider(
+  url: string,
+  firstPartyDomains: MatchOption[] = []
+): { domain?: string; name?: string; type?: ProviderType } | undefined {
+  if (!isValidUrl(url)) {
+    return undefined
+  }
+
+  let hostname: string
+  try {
+    hostname = buildUrl(url).hostname
+  } catch {
+    return undefined
+  }
+
+  if (!hostname) {
+    return undefined
+  }
+
+  // First-party: same hostname as the page, or matches configured firstPartyDomains
+  if (hostname === location.hostname || (firstPartyDomains.length > 0 && matchList(firstPartyDomains, hostname))) {
+    return { domain: hostname, type: 'first party' }
+  }
+
+  for (const provider of KNOWN_PROVIDERS) {
+    for (const domain of provider.domains) {
+      if (hostname === domain || hostname.endsWith(`.${domain}`)) {
+        return { domain: hostname, name: provider.name, type: provider.type }
+      }
+    }
+  }
+
+  // Unknown third-party
+  return { domain: hostname, type: 'other' }
+}
+
+const DATA_URL_REGEX = /data:(.+)?(;base64)?,/g
+export const MAX_RESOURCE_VALUE_CHAR_LENGTH = 24_000
+
+export function sanitizeIfLongDataUrl(url: string, lengthLimit: number = MAX_RESOURCE_VALUE_CHAR_LENGTH): string {
+  if (url.length <= lengthLimit || !url.startsWith('data:')) {
+    return url
+  }
+  // truncate url first to a random length to prevent match error when the url is too long
+  const dataUrlMatchArray = url.substring(0, 100).match(DATA_URL_REGEX)
+  if (!dataUrlMatchArray) {
+    return url
+  }
+  return `${dataUrlMatchArray[0]}[...]`
+}

package/src/domain/resource/retrieveInitialDocumentResourceTiming.ts

@@ -0,0 +1,27 @@
+import { runOnReadyState } from '@kubesense/kubesense-browser-core'
+import { RumPerformanceEntryType } from '../../browser/performanceObservable'
+import type { RumPerformanceResourceTiming } from '../../browser/performanceObservable'
+import type { RumConfiguration } from '../configuration'
+import { getDocumentTraceId } from '../tracing/getDocumentTraceId'
+import { getNavigationEntry } from '../../browser/performanceUtils'
+import { FAKE_INITIAL_DOCUMENT } from './resourceUtils'
+
+export function retrieveInitialDocumentResourceTiming(
+  configuration: RumConfiguration,
+  callback: (timing: RumPerformanceResourceTiming) => void,
+  getNavigationEntryImpl = getNavigationEntry
+) {
+  runOnReadyState(configuration, 'interactive', () => {
+    const navigationEntry = getNavigationEntryImpl()
+    const entry: RumPerformanceResourceTiming = Object.assign(navigationEntry.toJSON(), {
+      entryType: RumPerformanceEntryType.RESOURCE as const,
+      initiatorType: FAKE_INITIAL_DOCUMENT,
+      // The ResourceTiming duration entry should be `responseEnd - startTime`. With
+      // NavigationTiming entries, `startTime` is always 0, so set it to `responseEnd`.
+      duration: navigationEntry.responseEnd,
+      traceId: getDocumentTraceId(document),
+      toJSON: () => ({ ...entry, toJSON: undefined }),
+    })
+    callback(entry)
+  })
+}

package/src/domain/rumSessionManager.ts

@@ -0,0 +1,134 @@
+import type { RelativeTime, TrackingConsentState } from '@kubesense/kubesense-browser-core'
+import {
+  BridgeCapability,
+  Observable,
+  SESSION_NOT_TRACKED,
+  bridgeSupports,
+  noop,
+  performDraw,
+  startSessionManager,
+} from '@kubesense/kubesense-browser-core'
+import type { RumConfiguration } from './configuration'
+import type { LifeCycle } from './lifeCycle'
+import { LifeCycleEventType } from './lifeCycle'
+
+export const enum SessionType {
+  SYNTHETICS = 'synthetics',
+  USER = 'user',
+  CI_TEST = 'ci_test',
+}
+
+export const RUM_SESSION_KEY = 'rum'
+
+export interface RumSessionManager {
+  findTrackedSession: (startTime?: RelativeTime) => RumSession | undefined
+  expire: () => void
+  expireObservable: Observable<void>
+  setForcedReplay: () => void
+}
+
+export interface RumSession {
+  id: string
+  sessionReplay: SessionReplayState
+  anonymousId?: string
+}
+
+export const enum RumTrackingType {
+  NOT_TRACKED = SESSION_NOT_TRACKED,
+  TRACKED_WITH_SESSION_REPLAY = '1',
+  TRACKED_WITHOUT_SESSION_REPLAY = '2',
+}
+
+export const enum SessionReplayState {
+  OFF,
+  SAMPLED,
+  FORCED,
+}
+
+export function startRumSessionManager(
+  configuration: RumConfiguration,
+  lifeCycle: LifeCycle,
+  trackingConsentState: TrackingConsentState
+): RumSessionManager {
+  const sessionManager = startSessionManager(
+    configuration,
+    RUM_SESSION_KEY,
+    (rawTrackingType) => computeTrackingType(configuration, rawTrackingType),
+    trackingConsentState
+  )
+
+  sessionManager.expireObservable.subscribe(() => {
+    lifeCycle.notify(LifeCycleEventType.SESSION_EXPIRED)
+  })
+
+  sessionManager.renewObservable.subscribe(() => {
+    lifeCycle.notify(LifeCycleEventType.SESSION_RENEWED)
+  })
+
+  sessionManager.sessionStateUpdateObservable.subscribe(({ previousState, newState }) => {
+    if (!previousState.forcedReplay && newState.forcedReplay) {
+      const sessionEntity = sessionManager.findSession()
+      if (sessionEntity) {
+        sessionEntity.isReplayForced = true
+      }
+    }
+  })
+  return {
+    findTrackedSession: (startTime) => {
+      const session = sessionManager.findSession(startTime)
+      if (!session || session.trackingType === RumTrackingType.NOT_TRACKED) {
+        return
+      }
+      return {
+        id: session.id,
+        sessionReplay:
+          session.trackingType === RumTrackingType.TRACKED_WITH_SESSION_REPLAY
+            ? SessionReplayState.SAMPLED
+            : session.isReplayForced
+              ? SessionReplayState.FORCED
+              : SessionReplayState.OFF,
+        anonymousId: session.anonymousId,
+      }
+    },
+    expire: sessionManager.expire,
+    expireObservable: sessionManager.expireObservable,
+    setForcedReplay: () => sessionManager.updateSessionState({ forcedReplay: '1' }),
+  }
+}
+
+/**
+ * Start a tracked replay session stub
+ */
+export function startRumSessionManagerStub(): RumSessionManager {
+  const session: RumSession = {
+    id: '00000000-aaaa-0000-aaaa-000000000000',
+    sessionReplay: bridgeSupports(BridgeCapability.RECORDS) ? SessionReplayState.SAMPLED : SessionReplayState.OFF,
+  }
+  return {
+    findTrackedSession: () => session,
+    expire: noop,
+    expireObservable: new Observable(),
+    setForcedReplay: noop,
+  }
+}
+
+function computeTrackingType(configuration: RumConfiguration, rawTrackingType?: string) {
+  if (hasValidRumSession(rawTrackingType)) {
+    return rawTrackingType
+  }
+  if (!performDraw(configuration.sessionSampleRate)) {
+    return RumTrackingType.NOT_TRACKED
+  }
+  if (!performDraw(configuration.sessionReplaySampleRate)) {
+    return RumTrackingType.TRACKED_WITHOUT_SESSION_REPLAY
+  }
+  return RumTrackingType.TRACKED_WITH_SESSION_REPLAY
+}
+
+function hasValidRumSession(trackingType?: string): trackingType is RumTrackingType {
+  return (
+    trackingType === RumTrackingType.NOT_TRACKED ||
+    trackingType === RumTrackingType.TRACKED_WITH_SESSION_REPLAY ||
+    trackingType === RumTrackingType.TRACKED_WITHOUT_SESSION_REPLAY
+  )
+}

package/src/domain/sampler/sampler.ts

@@ -0,0 +1,63 @@
+import { performDraw } from '@kubesense/kubesense-browser-core'
+
+const sampleDecisionCache: Map<number, { sessionId: string; decision: boolean }> = new Map()
+
+export function isSampled(sessionId: string, sampleRate: number) {
+  // Shortcuts for common cases. This is not strictly necessary, but it makes the code faster for
+  // customers willing to ingest all traces.
+  if (sampleRate === 100) {
+    return true
+  }
+
+  if (sampleRate === 0) {
+    return false
+  }
+
+  const cachedDecision = sampleDecisionCache.get(sampleRate)
+  if (cachedDecision && sessionId === cachedDecision.sessionId) {
+    return cachedDecision.decision
+  }
+
+  let decision: boolean
+  // @ts-expect-error BigInt might not be defined in every browser we support
+  if (window.BigInt) {
+    decision = sampleUsingKnuthFactor(BigInt(`0x${sessionId.split('-')[4]}`), sampleRate)
+  } else {
+    // For simplicity, we don't use consistent sampling for browser without BigInt support
+    // TODO: remove this when all browser we support have BigInt support
+    decision = performDraw(sampleRate)
+  }
+  sampleDecisionCache.set(sampleRate, { sessionId, decision })
+  return decision
+}
+
+// Exported for tests
+export function resetSampleDecisionCache() {
+  sampleDecisionCache.clear()
+}
+
+/**
+ * Perform sampling using the Knuth factor method. This method offer consistent sampling result
+ * based on the provided identifier.
+ *
+ * @param identifier - The identifier to use for sampling.
+ * @param sampleRate - The sample rate in percentage between 0 and 100.
+ */
+export function sampleUsingKnuthFactor(identifier: bigint, sampleRate: number) {
+  // The formula is:
+  //
+  //   (identifier * knuthFactor) % 2^64 < sampleRate * 2^64
+  //
+  // Because JavaScript numbers are 64-bit floats, we can't represent 64-bit integers, and the
+  // modulo would be incorrect. Thus, we are using BigInts here.
+  //
+  // Note: All implementations have slight variations. Some of them use '<=' instead of '<', and
+  // use `sampleRate * 2^64 - 1` instead of `sampleRate * 2^64`. The following implementation
+  // should adhere to the spec and is a bit simpler than using a 2^64-1 limit as there are less
+  // BigInt arithmetic to write. In practice this does not matter, as we are using floating point
+  // numbers in the end, and Number(2n**64n-1n) === Number(2n**64n).
+  const knuthFactor = BigInt('1111111111111111111')
+  const twoPow64 = BigInt('0x10000000000000000') // 2n ** 64n
+  const hash = (identifier * knuthFactor) % twoPow64
+  return Number(hash) <= (sampleRate / 100) * Number(twoPow64)
+}

package/src/domain/startCustomerDataTelemetry.ts

@@ -0,0 +1,83 @@
+import type { Context, FlushEvent, Observable, Telemetry } from '@kubesense/kubesense-browser-core'
+import { ONE_SECOND, addTelemetryMetrics, setInterval, TelemetryMetrics } from '@kubesense/kubesense-browser-core'
+import type { RumConfiguration } from './configuration'
+import type { LifeCycle } from './lifeCycle'
+import { LifeCycleEventType } from './lifeCycle'
+
+export const MEASURES_PERIOD_DURATION = 10 * ONE_SECOND
+
+interface Measure extends Context {
+  min: number
+  max: number
+  sum: number
+}
+
+interface CurrentPeriodMeasures extends Context {
+  batchCount: number
+  batchBytesCount: Measure
+  batchMessagesCount: Measure
+}
+
+let currentPeriodMeasures: CurrentPeriodMeasures
+let batchHasRumEvent: boolean
+
+export function startCustomerDataTelemetry(
+  telemetry: Telemetry,
+  lifeCycle: LifeCycle,
+  batchFlushObservable: Observable<FlushEvent>
+) {
+  if (!telemetry.metricsEnabled) {
+    return
+  }
+
+  initCurrentPeriodMeasures()
+  batchHasRumEvent = false
+  // We measure the data of every view updates even if there could only be one per batch due to the upsert
+  // It means that contexts bytes count sums can be higher than it really is
+  lifeCycle.subscribe(LifeCycleEventType.RUM_EVENT_COLLECTED, () => {
+    batchHasRumEvent = true
+  })
+
+  batchFlushObservable.subscribe(({ bytesCount, messagesCount }) => {
+    // Don't measure batch that only contains telemetry events to avoid batch sending loop
+    // It could happen because after each batch we are adding a customer data measures telemetry event to the next one
+    if (!batchHasRumEvent) {
+      return
+    }
+    batchHasRumEvent = false
+
+    currentPeriodMeasures.batchCount += 1
+    updateMeasure(currentPeriodMeasures.batchBytesCount, bytesCount)
+    updateMeasure(currentPeriodMeasures.batchMessagesCount, messagesCount)
+  })
+
+  setInterval(sendCurrentPeriodMeasures, MEASURES_PERIOD_DURATION)
+}
+
+function sendCurrentPeriodMeasures() {
+  if (currentPeriodMeasures.batchCount === 0) {
+    return
+  }
+
+  // monitor-until: forever
+  addTelemetryMetrics(TelemetryMetrics.CUSTOMER_DATA_METRIC_NAME, currentPeriodMeasures)
+  initCurrentPeriodMeasures()
+}
+
+function createMeasure(): Measure {
+  return { min: Infinity, max: 0, sum: 0 }
+}
+
+function updateMeasure(measure: Measure, value: number) {
+  measure.sum += value
+  measure.min = Math.min(measure.min, value)
+  measure.max = Math.max(measure.max, value)
+}
+
+function initCurrentPeriodMeasures() {
+  currentPeriodMeasures = {
+    batchCount: 0,
+    batchBytesCount: createMeasure(),
+    batchMessagesCount: createMeasure(),
+  }
+}