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

package/esm/rumEvent.types.js

@@ -1,6 +0,0 @@
-/* eslint-disable */
-/**
- * DO NOT MODIFY IT BY HAND. Run `yarn json-schemas:sync` instead.
- */
-export {};
-//# sourceMappingURL=rumEvent.types.js.map

package/esm/rumEvent.types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"rumEvent.types.js","sourceRoot":"","sources":["../src/rumEvent.types.ts"],"names":[],"mappings":"AAAA,oBAAoB;AACpB;;GAEG"}

package/esm/transport/formDataTransport.d.ts

@@ -1,16 +0,0 @@
-import type { Encoder, DeflateEncoderStreamId, Context } from '@kubesense/kubesense-browser-core';
-import type { RumConfiguration } from '../domain/configuration';
-import type { LifeCycle } from '../domain/lifeCycle';
-/**
- * transport payload consist of an event and one or more attachments
- */
-export interface TransportPayload {
-    event: Context;
-    [key: string]: Context;
-}
-export interface Transport<T extends TransportPayload> {
-    send: (data: T) => Promise<void>;
-}
-export declare function createFormDataTransport<T extends TransportPayload>(configuration: RumConfiguration, lifeCycle: LifeCycle, createEncoder: (streamId: DeflateEncoderStreamId) => Encoder, streamId: DeflateEncoderStreamId): {
-    send({ event, ...attachments }: T): Promise<void>;
-};

package/esm/transport/formDataTransport.js

@@ -1,43 +0,0 @@
-import { addTelemetryDebug, createHttpRequest, jsonStringify, objectEntries } from '@kubesense/kubesense-browser-core';
-export function createFormDataTransport(configuration, lifeCycle, createEncoder, streamId) {
-    const reportError = (error) => {
-        lifeCycle.notify(14 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, { error });
-        // monitor-until: forever, to keep an eye on the errors reported to customers
-        addTelemetryDebug('Error reported to customer', { 'error.message': error.message });
-    };
-    const httpRequest = createHttpRequest([configuration.profilingEndpointBuilder], reportError);
-    const encoder = createEncoder(streamId);
-    return {
-        async send({ event, ...attachments }) {
-            const formData = new FormData();
-            const serializedEvent = jsonStringify(event);
-            if (!serializedEvent) {
-                throw new Error('Failed to serialize event');
-            }
-            formData.append('event', new Blob([serializedEvent], { type: 'application/json' }), 'event.json');
-            let bytesCount = serializedEvent.length;
-            for (const [key, value] of objectEntries(attachments)) {
-                const serializedValue = jsonStringify(value);
-                if (!serializedValue) {
-                    throw new Error('Failed to serialize attachment');
-                }
-                const result = await encode(encoder, serializedValue);
-                bytesCount += result.outputBytesCount;
-                formData.append(key, new Blob([result.output]), key);
-            }
-            httpRequest.send({
-                data: formData,
-                bytesCount,
-            });
-        },
-    };
-}
-function encode(encoder, data) {
-    return new Promise((resolve) => {
-        encoder.write(data);
-        encoder.finish((encoderResult) => {
-            resolve(encoderResult);
-        });
-    });
-}
-//# sourceMappingURL=formDataTransport.js.map

package/esm/transport/formDataTransport.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"formDataTransport.js","sourceRoot":"","sources":["../../src/transport/formDataTransport.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAA;AAiBtH,MAAM,UAAU,uBAAuB,CACrC,aAA+B,EAC/B,SAAoB,EACpB,aAA4D,EAC5D,QAAgC;IAEhC,MAAM,WAAW,GAAG,CAAC,KAAe,EAAE,EAAE;QACtC,SAAS,CAAC,MAAM,kDAAyC,EAAE,KAAK,EAAE,CAAC,CAAA;QAEnE,6EAA6E;QAC7E,iBAAiB,CAAC,4BAA4B,EAAE,EAAE,eAAe,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC,CAAA;IACrF,CAAC,CAAA;IAED,MAAM,WAAW,GAAG,iBAAiB,CAAC,CAAC,aAAa,CAAC,wBAAwB,CAAC,EAAE,WAAW,CAAC,CAAA;IAE5F,MAAM,OAAO,GAAG,aAAa,CAAC,QAAQ,CAAC,CAAA;IAEvC,OAAO;QACL,KAAK,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,GAAG,WAAW,EAAK;YACrC,MAAM,QAAQ,GAAG,IAAI,QAAQ,EAAE,CAAA;YAC/B,MAAM,eAAe,GAAG,aAAa,CAAC,KAAK,CAAC,CAAA;YAE5C,IAAI,CAAC,eAAe,EAAE,CAAC;gBACrB,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAA;YAC9C,CAAC;YAED,QAAQ,CAAC,MAAM,CAAC,OAAO,EAAE,IAAI,IAAI,CAAC,CAAC,eAAe,CAAC,EAAE,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC,EAAE,YAAY,CAAC,CAAA;YAEjG,IAAI,UAAU,GAAG,eAAe,CAAC,MAAM,CAAA;YAEvC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,aAAa,CAAC,WAAsC,CAAC,EAAE,CAAC;gBACjF,MAAM,eAAe,GAAG,aAAa,CAAC,KAAK,CAAC,CAAA;gBAE5C,IAAI,CAAC,eAAe,EAAE,CAAC;oBACrB,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAA;gBACnD,CAAC;gBAED,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,OAAO,EAAE,eAAe,CAAC,CAAA;gBAErD,UAAU,IAAI,MAAM,CAAC,gBAAgB,CAAA;gBACrC,QAAQ,CAAC,MAAM,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,CAAA;YACtD,CAAC;YAED,WAAW,CAAC,IAAI,CAAC;gBACf,IAAI,EAAE,QAAQ;gBACd,UAAU;aACX,CAAC,CAAA;QACJ,CAAC;KACF,CAAA;AACH,CAAC;AAED,SAAS,MAAM,CAAsC,OAAmB,EAAE,IAAY;IACpF,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QAC7B,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QAEnB,OAAO,CAAC,MAAM,CAAC,CAAC,aAAa,EAAE,EAAE;YAC/B,OAAO,CAAC,aAAa,CAAC,CAAA;QACxB,CAAC,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;AACJ,CAAC"}

package/esm/transport/startRumBatch.d.ts

@@ -1,5 +0,0 @@
-import type { Observable, RawError, PageMayExitEvent, Encoder } from '@kubesense/kubesense-browser-core';
-import { DeflateEncoderStreamId } from '@kubesense/kubesense-browser-core';
-import type { RumConfiguration } from '../domain/configuration';
-import type { LifeCycle } from '../domain/lifeCycle';
-export declare function startRumBatch(configuration: RumConfiguration, lifeCycle: LifeCycle, reportError: (error: RawError) => void, pageMayExitObservable: Observable<PageMayExitEvent>, sessionExpireObservable: Observable<void>, createEncoder: (streamId: DeflateEncoderStreamId) => Encoder): import("@kubesense/kubesense-browser-core/cjs/transport/batch").Batch;

package/esm/transport/startRumBatch.js

@@ -1,30 +0,0 @@
-import { createBatch, createFlushController, createHttpRequest } from '@kubesense/kubesense-browser-core';
-import { RumEventType } from '../rawRumEvent.types';
-export function startRumBatch(configuration, lifeCycle, reportError, pageMayExitObservable, sessionExpireObservable, createEncoder) {
-    const endpoints = [configuration.rumEndpointBuilder];
-    if (configuration.replica) {
-        endpoints.push(configuration.replica.rumEndpointBuilder);
-    }
-    const request = createHttpRequest(endpoints, reportError);
-    const batch = createBatch({
-        encoder: createEncoder(2 /* DeflateEncoderStreamId.RUM */),
-        request,
-        flushController: createFlushController({
-            pageMayExitObservable,
-            sessionExpireObservable,
-        }),
-    });
-    pageMayExitObservable.subscribe(() => {
-        request.sendQueuedOnExit();
-    });
-    lifeCycle.subscribe(13 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, (serverRumEvent) => {
-        if (serverRumEvent.type === RumEventType.VIEW) {
-            batch.upsert(serverRumEvent, serverRumEvent.view.id);
-        }
-        else {
-            batch.add(serverRumEvent);
-        }
-    });
-    return batch;
-}
-//# sourceMappingURL=startRumBatch.js.map

package/esm/transport/startRumBatch.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"startRumBatch.js","sourceRoot":"","sources":["../../src/transport/startRumBatch.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,qBAAqB,EAAE,iBAAiB,EAA0B,MAAM,mCAAmC,CAAA;AAKjI,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAEnD,MAAM,UAAU,aAAa,CAC3B,aAA+B,EAC/B,SAAoB,EACpB,WAAsC,EACtC,qBAAmD,EACnD,uBAAyC,EACzC,aAA4D;IAE5D,MAAM,SAAS,GAAG,CAAC,aAAa,CAAC,kBAAkB,CAAC,CAAA;IACpD,IAAI,aAAa,CAAC,OAAO,EAAE,CAAC;QAC1B,SAAS,CAAC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAA;IAC1D,CAAC;IAED,MAAM,OAAO,GAAG,iBAAiB,CAAC,SAAS,EAAE,WAAW,CAAC,CAAA;IAEzD,MAAM,KAAK,GAAG,WAAW,CAAC;QACxB,OAAO,EAAE,aAAa,oCAA4B;QAClD,OAAO;QACP,eAAe,EAAE,qBAAqB,CAAC;YACrC,qBAAqB;YACrB,uBAAuB;SACxB,CAAC;KACH,CAAC,CAAA;IAEF,qBAAqB,CAAC,SAAS,CAAC,GAAG,EAAE;QACnC,OAAO,CAAC,gBAAgB,EAAE,CAAA;IAC5B,CAAC,CAAC,CAAA;IAEF,SAAS,CAAC,SAAS,kDAAyC,CAAC,cAAiC,EAAE,EAAE;QAChG,IAAI,cAAc,CAAC,IAAI,KAAK,YAAY,CAAC,IAAI,EAAE,CAAC;YAC9C,KAAK,CAAC,MAAM,CAAC,cAAc,EAAE,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;QACtD,CAAC;aAAM,CAAC;YACN,KAAK,CAAC,GAAG,CAAC,cAAc,CAAC,CAAA;QAC3B,CAAC;IACH,CAAC,CAAC,CAAA;IAEF,OAAO,KAAK,CAAA;AACd,CAAC"}

package/esm/transport/startRumEventBridge.d.ts

@@ -1,2 +0,0 @@
-import type { LifeCycle } from '../domain/lifeCycle';
-export declare function startRumEventBridge(lifeCycle: LifeCycle): void;

package/esm/transport/startRumEventBridge.js

@@ -1,8 +0,0 @@
-import { getEventBridge } from '@kubesense/kubesense-browser-core';
-export function startRumEventBridge(lifeCycle) {
-    const bridge = getEventBridge();
-    lifeCycle.subscribe(13 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, (serverRumEvent) => {
-        bridge.send('rum', serverRumEvent);
-    });
-}
-//# sourceMappingURL=startRumEventBridge.js.map

package/esm/transport/startRumEventBridge.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"startRumEventBridge.js","sourceRoot":"","sources":["../../src/transport/startRumEventBridge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAA;AAKlE,MAAM,UAAU,mBAAmB,CAAC,SAAoB;IACtD,MAAM,MAAM,GAAG,cAAc,EAAoB,CAAA;IAEjD,SAAS,CAAC,SAAS,kDAAyC,CAAC,cAAc,EAAE,EAAE;QAC7E,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,cAAc,CAAC,CAAA;IACpC,CAAC,CAAC,CAAA;AACJ,CAAC"}

package/src/browser/firstInputPolyfill.ts

@@ -1,87 +0,0 @@
-import type { Duration, RelativeTime } from '@kubesense/kubesense-browser-core'
-import { addEventListeners, dateNow, DOM_EVENT, relativeNow } from '@kubesense/kubesense-browser-core'
-import type { RumConfiguration } from '../domain/configuration'
-
-/**
- * first-input timing entry polyfill based on
- * https://github.com/GoogleChrome/web-vitals/blob/master/src/lib/polyfills/firstInputPolyfill.ts
- */
-export function retrieveFirstInputTiming(
-  configuration: RumConfiguration,
-  callback: (timing: PerformanceEventTiming) => void
-) {
-  const startTimeStamp = dateNow()
-  let timingSent = false
-
-  const { stop: removeEventListeners } = addEventListeners(
-    configuration,
-    window,
-    [DOM_EVENT.CLICK, DOM_EVENT.MOUSE_DOWN, DOM_EVENT.KEY_DOWN, DOM_EVENT.TOUCH_START, DOM_EVENT.POINTER_DOWN],
-    (evt) => {
-      // Only count cancelable events, which should trigger behavior important to the user.
-      if (!evt.cancelable) {
-        return
-      }
-
-      // This timing will be used to compute the "first Input delay", which is the delta between
-      // when the system received the event (e.g. evt.timeStamp) and when it could run the callback
-      // (e.g. performance.now()).
-      const timing: PerformanceEventTiming = {
-        entryType: 'first-input',
-        processingStart: relativeNow(),
-        processingEnd: relativeNow(),
-        startTime: evt.timeStamp as RelativeTime,
-        duration: 0 as Duration, // arbitrary value to avoid nullable duration and simplify INP logic
-        name: '',
-        cancelable: false,
-        target: null,
-        toJSON: () => ({}),
-      }
-
-      if (evt.type === DOM_EVENT.POINTER_DOWN) {
-        sendTimingIfPointerIsNotCancelled(configuration, timing)
-      } else {
-        sendTiming(timing)
-      }
-    },
-    { passive: true, capture: true }
-  )
-
-  return { stop: removeEventListeners }
-
-  /**
-   * Pointer events are a special case, because they can trigger main or compositor thread behavior.
-   * We differentiate these cases based on whether or not we see a pointercancel event, which are
-   * fired when we scroll. If we're scrolling we don't need to report input delay since FID excludes
-   * scrolling and pinch/zooming.
-   */
-  function sendTimingIfPointerIsNotCancelled(configuration: RumConfiguration, timing: PerformanceEventTiming) {
-    addEventListeners(
-      configuration,
-      window,
-      [DOM_EVENT.POINTER_UP, DOM_EVENT.POINTER_CANCEL],
-      (event) => {
-        if (event.type === DOM_EVENT.POINTER_UP) {
-          sendTiming(timing)
-        }
-      },
-      { once: true }
-    )
-  }
-
-  function sendTiming(timing: PerformanceEventTiming) {
-    if (!timingSent) {
-      timingSent = true
-      removeEventListeners()
-      // In some cases the recorded delay is clearly wrong, e.g. it's negative or it's larger than
-      // the time between now and when the page was loaded.
-      // - https://github.com/GoogleChromeLabs/first-input-delay/issues/4
-      // - https://github.com/GoogleChromeLabs/first-input-delay/issues/6
-      // - https://github.com/GoogleChromeLabs/first-input-delay/issues/7
-      const delay = timing.processingStart - timing.startTime
-      if (delay >= 0 && delay < dateNow() - startTimeStamp) {
-        callback(timing)
-      }
-    }
-  }
-}

package/src/domain/error/trackConsoleError.ts

@@ -1,14 +0,0 @@
-import type { Observable, RawError } from '@kubesense/kubesense-browser-core'
-import { initConsoleObservable, ConsoleApiName } from '@kubesense/kubesense-browser-core'
-
-export function trackConsoleError(errorObservable: Observable<RawError>) {
-  const subscription = initConsoleObservable([ConsoleApiName.error]).subscribe((consoleLog) =>
-    errorObservable.notify(consoleLog.error)
-  )
-
-  return {
-    stop: () => {
-      subscription.unsubscribe()
-    },
-  }
-}

package/src/domain/resource/matchRequestResourceEntry.ts

@@ -1,68 +0,0 @@
-import type { Duration, RelativeTime } from '@kubesense/kubesense-browser-core'
-import { addDuration } from '@kubesense/kubesense-browser-core'
-import type { RumPerformanceResourceTiming } from '../../browser/performanceObservable'
-import type { RequestCompleteEvent } from '../requestCollection'
-import { hasValidResourceEntryDuration } from './resourceUtils'
-
-interface Timing {
-  startTime: RelativeTime
-  duration: Duration
-}
-
-const alreadyMatchedEntries = new WeakSet<PerformanceEntry>()
-
-/**
- * Look for corresponding timing in resource timing buffer
- *
- * Observations:
- * - Timing (start, end) are nested inside the request (start, end)
- * - Some timing can be not exactly nested, being off by < 1 ms
- *
- * Strategy:
- * - from valid nested entries (with 1 ms error margin)
- * - filter out timing that were already matched to a request
- * - then, if a single timing match, return the timing
- * - otherwise we can't decide, return undefined
- */
-export function matchRequestResourceEntry(request: RequestCompleteEvent) {
-  if (!performance || !('getEntriesByName' in performance)) {
-    return
-  }
-  const sameNameEntries = performance.getEntriesByName(request.url, 'resource') as RumPerformanceResourceTiming[]
-
-  if (!sameNameEntries.length || !('toJSON' in sameNameEntries[0])) {
-    return
-  }
-
-  const candidates = sameNameEntries
-    .filter((entry) => !alreadyMatchedEntries.has(entry))
-    // Only require valid duration — needed for the isBetween time-window check.
-    // hasValidResourceEntryTimings is intentionally NOT used here: cached resources often have
-    // timing fields zeroed out (browser behaviour) even though their duration and start time
-    // are correct and the entry should still be matched to its request.
-    .filter((entry) => hasValidResourceEntryDuration(entry))
-    .filter((entry) =>
-      isBetween(
-        entry,
-        request.startClocks.relative,
-        endTime({ startTime: request.startClocks.relative, duration: request.duration })
-      )
-    )
-
-  if (candidates.length === 1) {
-    alreadyMatchedEntries.add(candidates[0])
-
-    return candidates[0].toJSON() as RumPerformanceResourceTiming
-  }
-
-  return
-}
-
-function endTime(timing: Timing) {
-  return addDuration(timing.startTime, timing.duration)
-}
-
-function isBetween(timing: Timing, start: RelativeTime, end: RelativeTime) {
-  const errorMargin = 1 as Duration
-  return timing.startTime >= start - errorMargin && endTime(timing) <= addDuration(end, errorMargin)
-}

package/src/domain/resource/retrieveInitialDocumentResourceTiming.ts

@@ -1,27 +0,0 @@
-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

@@ -1,134 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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/tracing/sampler.ts

@@ -1,69 +0,0 @@
-import { performDraw } from '@kubesense/kubesense-browser-core'
-
-let sampleDecisionCache: { sessionId: string; decision: boolean } | undefined
-
-export function isTraceSampled(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
-  }
-
-  if (sampleDecisionCache && sessionId === sampleDecisionCache.sessionId) {
-    return sampleDecisionCache.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 = { sessionId, decision }
-  return decision
-}
-
-// Exported for tests
-export function resetSampleDecisionCache() {
-  sampleDecisionCache = undefined
-}
-
-/**
- * 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.
-  //
-  // Implementation in other languages:
-  // * Go     https://github.com/kubsense-ai/kubesense-trace-go/blob/ec6fbb1f2d517b7b8e69961052adf7136f3af773/ddtrace/tracer/sampler.go#L86-L91
-  // * Python https://github.com/kubsense/kubesense-trace-py/blob/0cee2f066fb6e79aa15947c1514c0f406dea47c5/ddtrace/sampling_rule.py#L197
-  // * Ruby   https://github.com/kubsense/kubesense-trace-rb/blob/1a6e255cdcb7e7e22235ea5955f90f6dfa91045d/lib/kubesense/tracing/sampling/rate_sampler.rb#L42
-  // * C++    https://github.com/kubsense/kubesense-trace-cpp/blob/159629edc438ae45f2bb318eb7bd51abd05e94b5/src/kubesense/trace_sampler.cpp#L58
-  // * Java   https://github.com/kubsense/kubesense-trace-java/blob/896dd6b380533216e0bdee59614606c8272d313e/kubesense-trace-core/src/main/java/kubesense/trace/common/sampling/DeterministicSampler.java#L48
-  //
-  // 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)
-}