@kubesense/kubesense-browser-rum-core 1.0.0

package/esm/rumEvent.types.js

@@ -0,0 +1,6 @@
+/* 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

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

package/esm/transport/formDataTransport.d.ts

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

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

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

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

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

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

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

package/esm/transport/startRumEventBridge.js

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

@@ -0,0 +1 @@
+{"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/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@kubesense/kubesense-browser-rum-core",
+  "version": "1.0.0",
+  "license": "Apache-2.0",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "types": "cjs/index.d.ts",
+  "scripts": {
+    "build": "node ../../scripts/build/build-package.ts --modules"
+  },
+  "dependencies": {
+    "@kubesense/kubesense-browser-core": "1.0.0"
+  },
+  "devDependencies": {
+    "ajv": "8.17.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kubesense-ai/kubesense-browser-sdk.git",
+    "directory": "packages/rum-core"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "5cac939a4795c5a54c2b29417e6434a8a3078d4f"
+}

package/src/boot/preStartRum.ts

@@ -0,0 +1,298 @@
+import type { TrackingConsentState, DeflateWorker, Context, ContextManager, BoundedBuffer } from '@kubesense/kubesense-browser-core'
+import {
+  createBoundedBuffer,
+  display,
+  canUseEventBridge,
+  displayAlreadyInitializedError,
+  willSyntheticsInjectRum,
+  noop,
+  timeStampNow,
+  clocksNow,
+  getEventBridge,
+  initFeatureFlags,
+  addTelemetryConfiguration,
+  initFetchObservable,
+  CustomerContextKey,
+  buildAccountContextManager,
+  buildGlobalContextManager,
+  buildUserContextManager,
+  monitorError,
+  sanitize,
+} from '@kubesense/kubesense-browser-core'
+import type { RumConfiguration, RumInitConfiguration } from '../domain/configuration'
+import {
+  validateAndBuildRumConfiguration,
+  fetchAndApplyRemoteConfiguration,
+  serializeRumConfiguration,
+} from '../domain/configuration'
+import type { ViewOptions } from '../domain/view/trackViews'
+import type {
+  DurationVital,
+  CustomVitalsState,
+  FeatureOperationOptions,
+  FailureReason,
+} from '../domain/vital/vitalCollection'
+import { startDurationVital, stopDurationVital } from '../domain/vital/vitalCollection'
+import { callPluginsMethod } from '../domain/plugins'
+import type { StartRumResult } from './startRum'
+import type { RumPublicApiOptions, Strategy } from './rumPublicApi'
+
+export function createPreStartStrategy(
+  { ignoreInitIfSyntheticsWillInjectRum = true, startDeflateWorker }: RumPublicApiOptions,
+  trackingConsentState: TrackingConsentState,
+  customVitalsState: CustomVitalsState,
+  doStartRum: (
+    configuration: RumConfiguration,
+    deflateWorker: DeflateWorker | undefined,
+    initialViewOptions?: ViewOptions
+  ) => StartRumResult
+): Strategy {
+  const bufferApiCalls = createBoundedBuffer<StartRumResult>()
+
+  // TODO next major: remove the globalContextManager, userContextManager and accountContextManager from preStartStrategy and use an empty context instead
+  const globalContext = buildGlobalContextManager()
+  bufferContextCalls(globalContext, CustomerContextKey.globalContext, bufferApiCalls)
+
+  const userContext = buildUserContextManager()
+  bufferContextCalls(userContext, CustomerContextKey.userContext, bufferApiCalls)
+
+  const accountContext = buildAccountContextManager()
+  bufferContextCalls(accountContext, CustomerContextKey.accountContext, bufferApiCalls)
+
+  let firstStartViewCall:
+    | { options: ViewOptions | undefined; callback: (startRumResult: StartRumResult) => void }
+    | undefined
+  let deflateWorker: DeflateWorker | undefined
+
+  let cachedInitConfiguration: RumInitConfiguration | undefined
+  let cachedConfiguration: RumConfiguration | undefined
+
+  const trackingConsentStateSubscription = trackingConsentState.observable.subscribe(tryStartRum)
+
+  const emptyContext: Context = {}
+
+  function tryStartRum() {
+    if (!cachedInitConfiguration || !cachedConfiguration || !trackingConsentState.isGranted()) {
+      return
+    }
+
+    trackingConsentStateSubscription.unsubscribe()
+
+    let initialViewOptions: ViewOptions | undefined
+
+    if (cachedConfiguration.trackViewsManually) {
+      if (!firstStartViewCall) {
+        return
+      }
+      // An initial view is always created when starting RUM.
+      // When tracking views automatically, any startView call before RUM start creates an extra
+      // view.
+      // When tracking views manually, we use the ViewOptions from the first startView call as the
+      // initial view options, and we remove the actual startView call so we don't create an extra
+      // view.
+      bufferApiCalls.remove(firstStartViewCall.callback)
+      initialViewOptions = firstStartViewCall.options
+    }
+
+    const startRumResult = doStartRum(cachedConfiguration, deflateWorker, initialViewOptions)
+
+    bufferApiCalls.drain(startRumResult)
+  }
+
+  function doInit(initConfiguration: RumInitConfiguration, errorStack?: string) {
+    const eventBridgeAvailable = canUseEventBridge()
+    if (eventBridgeAvailable) {
+      initConfiguration = overrideInitConfigurationForBridge(initConfiguration)
+    }
+
+    // Update the exposed initConfiguration to reflect the bridge and remote configuration overrides
+    cachedInitConfiguration = initConfiguration
+    addTelemetryConfiguration(serializeRumConfiguration(initConfiguration))
+
+    if (cachedConfiguration) {
+      displayAlreadyInitializedError('KUBESENSE_SDK', initConfiguration)
+      return
+    }
+
+    const configuration = validateAndBuildRumConfiguration(initConfiguration, errorStack)
+    if (!configuration) {
+      return
+    }
+
+    if (!eventBridgeAvailable && !configuration.sessionStoreStrategyType) {
+      display.warn('No storage available for session. We will not send any data.')
+      return
+    }
+
+    if (configuration.compressIntakeRequests && !eventBridgeAvailable && startDeflateWorker) {
+      deflateWorker = startDeflateWorker(
+        configuration,
+        'Kubsesense RUM',
+        // Worker initialization can fail asynchronously, especially in Firefox where even CSP
+        // issues are reported asynchronously. For now, the SDK will continue its execution even if
+        // data won't be sent to Kubsesense. We could improve this behavior in the future.
+        noop
+      )
+      if (!deflateWorker) {
+        // `startDeflateWorker` should have logged an error message explaining the issue
+        return
+      }
+    }
+
+    cachedConfiguration = configuration
+    // Instrument fetch to track network requests
+    // This is needed in case the consent is not granted and some customer
+    // library (Apollo Client) is storing uninstrumented fetch to be used later
+    // The subscription is needed so that the instrumentation process is completed
+    initFetchObservable().subscribe(noop)
+
+    trackingConsentState.tryToInit(configuration.trackingConsent)
+    tryStartRum()
+  }
+
+  const addDurationVital = (vital: DurationVital) => {
+    bufferApiCalls.add((startRumResult) => startRumResult.addDurationVital(vital))
+  }
+
+  const addOperationStepVital = (
+    name: string,
+    stepType: 'start' | 'end',
+    options?: FeatureOperationOptions,
+    failureReason?: FailureReason
+  ) => {
+    bufferApiCalls.add((startRumResult) =>
+      startRumResult.addOperationStepVital(
+        sanitize(name)!,
+        stepType,
+        sanitize(options) as FeatureOperationOptions,
+        sanitize(failureReason) as FailureReason | undefined
+      )
+    )
+  }
+
+  const strategy: Strategy = {
+    init(initConfiguration, publicApi, errorStack) {
+      if (!initConfiguration) {
+        display.error('Missing configuration')
+        return
+      }
+      // Set the experimental feature flags as early as possible, so we can use them in most places
+      initFeatureFlags(initConfiguration.enableExperimentalFeatures)
+
+      // Expose the initial configuration regardless of initialization success.
+      cachedInitConfiguration = initConfiguration
+
+      // If we are in a Synthetics test configured to automatically inject a RUM instance, we want
+      // to completely discard the customer application RUM instance by ignoring their init() call.
+      // But, we should not ignore the init() call from the Synthetics-injected RUM instance, so the
+      // internal `ignoreInitIfSyntheticsWillInjectRum` option is here to bypass this condition.
+      if (ignoreInitIfSyntheticsWillInjectRum && willSyntheticsInjectRum()) {
+        return
+      }
+
+      callPluginsMethod(initConfiguration.plugins, 'onInit', { initConfiguration, publicApi })
+
+      if (initConfiguration.remoteConfigurationId) {
+        fetchAndApplyRemoteConfiguration(initConfiguration, { user: userContext, context: globalContext })
+          .then((initConfiguration) => {
+            if (initConfiguration) {
+              doInit(initConfiguration, errorStack)
+            }
+          })
+          .catch(monitorError)
+      } else {
+        doInit(initConfiguration, errorStack)
+      }
+    },
+
+    get initConfiguration() {
+      return cachedInitConfiguration
+    },
+
+    getInternalContext: noop as () => undefined,
+
+    stopSession: noop,
+
+    addTiming(name, time = timeStampNow()) {
+      bufferApiCalls.add((startRumResult) => startRumResult.addTiming(name, time))
+    },
+
+    startView(options, startClocks = clocksNow()) {
+      const callback = (startRumResult: StartRumResult) => {
+        startRumResult.startView(options, startClocks)
+      }
+      bufferApiCalls.add(callback)
+
+      if (!firstStartViewCall) {
+        firstStartViewCall = { options, callback }
+        tryStartRum()
+      }
+    },
+
+    setViewName(name) {
+      bufferApiCalls.add((startRumResult) => startRumResult.setViewName(name))
+    },
+
+    // View context APIs
+
+    setViewContext(context) {
+      bufferApiCalls.add((startRumResult) => startRumResult.setViewContext(context))
+    },
+
+    setViewContextProperty(key, value) {
+      bufferApiCalls.add((startRumResult) => startRumResult.setViewContextProperty(key, value))
+    },
+
+    getViewContext: () => emptyContext,
+
+    globalContext,
+    userContext,
+    accountContext,
+
+    addAction(action) {
+      bufferApiCalls.add((startRumResult) => startRumResult.addAction(action))
+    },
+
+    addError(providedError) {
+      bufferApiCalls.add((startRumResult) => startRumResult.addError(providedError))
+    },
+
+    addFeatureFlagEvaluation(key, value) {
+      bufferApiCalls.add((startRumResult) => startRumResult.addFeatureFlagEvaluation(key, value))
+    },
+
+    startDurationVital(name, options) {
+      return startDurationVital(customVitalsState, name, options)
+    },
+
+    stopDurationVital(name, options) {
+      stopDurationVital(addDurationVital, customVitalsState, name, options)
+    },
+
+    addDurationVital,
+    addOperationStepVital,
+  }
+
+  return strategy
+}
+
+function overrideInitConfigurationForBridge(initConfiguration: RumInitConfiguration): RumInitConfiguration {
+  return {
+    ...initConfiguration,
+    applicationId: '00000000-aaaa-0000-aaaa-000000000000',
+    clientToken: 'empty',
+    sessionSampleRate: 100,
+    defaultPrivacyLevel: initConfiguration.defaultPrivacyLevel ?? getEventBridge()?.getPrivacyLevel(),
+  }
+}
+
+function bufferContextCalls(
+  preStartContextManager: ContextManager,
+  name: CustomerContextKey,
+  bufferApiCalls: BoundedBuffer<StartRumResult>
+) {
+  preStartContextManager.changeObservable.subscribe(() => {
+    const context = preStartContextManager.getContext()
+    bufferApiCalls.add((startRumResult) => startRumResult[name].setContext(context))
+  })
+}