@openobserve/browser-core 0.2.11 → 0.2.12-beta.13

package/src/domain/configuration/endpointBuilder.ts

@@ -1,51 +1,37 @@
-import type { RetryInfo, FlushReason } from '../../transport'
+import type { Payload } from '../../transport'
 import { timeStampNow } from '../../tools/utils/timeUtils'
 import { normalizeUrl } from '../../tools/utils/urlPolyfill'
-import { ExperimentalFeature, isExperimentalFeatureEnabled } from '../../tools/experimentalFeatures'
 import { generateUUID } from '../../tools/utils/stringUtils'
+import { INTAKE_SITE_FED_STAGING, INTAKE_SITE_US1, PCI_INTAKE_HOST_US1 } from '../intakeSites'
 import type { InitConfiguration } from './configuration'
-import { INTAKE_SITE_AP1, INTAKE_SITE_US1 } from './intakeSites'
 
 // replaced at build time
 declare const __BUILD_ENV__SDK_VERSION__: string
 
-export const ENDPOINTS = {
-  logs: 'logs',
-  rum: 'rum',
-  sessionReplay: 'session-replay',
-} as const
-
-const INTAKE_TRACKS = {
-  logs: 'logs',
-  rum: 'rum',
-  sessionReplay: 'replay',
-}
-
-export type EndpointType = keyof typeof ENDPOINTS
+export type TrackType = 'logs' | 'rum' | 'replay' | 'profile' | 'exposures'
+export type ApiType =
+  | 'fetch-keepalive'
+  | 'fetch'
+  | 'beacon'
+  // 'manual' reflects that the request have been sent manually, outside of the SDK (ex: via curl or
+  // a Node.js script).
+  | 'manual'
 
 export type EndpointBuilder = ReturnType<typeof createEndpointBuilder>
 
 export function createEndpointBuilder(
   initConfiguration: InitConfiguration,
-  endpointType: EndpointType,
-  configurationTags: string[]
+  trackType: TrackType,
+  extraParameters?: string[]
 ) {
-  const buildUrlWithParameters = createEndpointUrlWithParametersBuilder(initConfiguration, endpointType)
+  const buildUrlWithParameters = createEndpointUrlWithParametersBuilder(initConfiguration, trackType)
 
   return {
-    build(api: 'xhr' | 'fetch' | 'beacon', flushReason?: FlushReason, retry?: RetryInfo) {
-      const parameters = buildEndpointParameters(
-        initConfiguration,
-        endpointType,
-        configurationTags,
-        api,
-        flushReason,
-        retry
-      )
+    build(api: ApiType, payload: Payload) {
+      const parameters = buildEndpointParameters(initConfiguration, trackType, api, payload, extraParameters)
       return buildUrlWithParameters(parameters)
     },
-    urlPrefix: buildUrlWithParameters(''),
-    endpointType,
+    trackType,
   }
 }
 
@@ -56,32 +42,27 @@ export function createEndpointBuilder(
  */
 function createEndpointUrlWithParametersBuilder(
   initConfiguration: InitConfiguration,
-  endpointType: EndpointType
+  trackType: TrackType
 ): (parameters: string) => string {
   const { proxy, proxyUrl, apiVersion, organizationIdentifier, insecureHTTP } = initConfiguration
 
-  const path = `/rum/${apiVersion}/${organizationIdentifier}/${INTAKE_TRACKS[endpointType]}`
+  const path = `/rum/${apiVersion}/${organizationIdentifier}/${INTAKE_TRACKS[trackType]}`
 
   if (proxy) {
     const normalizedProxyUrl = normalizeUrl(proxy)
     return (parameters) => `${normalizedProxyUrl}?ooforward=${encodeURIComponent(`${path}?${parameters}`)}`
   }
-
-  const host = buildEndpointHost(initConfiguration, endpointType)
-
-  if (proxy === undefined && proxyUrl) {
-    // TODO: remove this in a future major.
-    const normalizedProxyUrl = normalizeUrl(proxyUrl)
-    return (parameters) =>
-      `${normalizedProxyUrl}?ooforward=${encodeURIComponent(`https://${host}${path}?${parameters}`)}`
+  if (typeof proxy === 'function') {
+    return (parameters) => proxy({ path, parameters })
   }
-
-  const protocol = insecureHTTP ? 'http' : 'https'
-
-  return (parameters) => `${protocol}://${host}${path}?${parameters}`
+  const host = buildEndpointHost(trackType, initConfiguration)
+  return (parameters) => `https://${host}${path}?${parameters}`
 }
 
-function buildEndpointHost(initConfiguration: InitConfiguration, endpointType: EndpointType) {
+export function buildEndpointHost(
+  trackType: TrackType,
+  initConfiguration: InitConfiguration & { usePciIntake?: boolean }
+) {
   const { site = INTAKE_SITE_US1, internalAnalyticsSubdomain } = initConfiguration
 
   return site
@@ -89,10 +70,13 @@ function buildEndpointHost(initConfiguration: InitConfiguration, endpointType: E
     return `${internalAnalyticsSubdomain}.${INTAKE_SITE_US1}`
   }
 
+  if (site === INTAKE_SITE_FED_STAGING) {
+    return `http-intake.logs.${site}`
+  }
+
   const domainParts = site.split('.')
   const extension = domainParts.pop()
-  const subdomain = site !== INTAKE_SITE_AP1 ? `${ENDPOINTS[endpointType]}.` : ''
-  return `${subdomain}browser-intake-${domainParts.join('-')}.${extension!}`
+  return `browser-intake-${domainParts.join('-')}.${extension!}`
 }
 
 /**
@@ -100,32 +84,32 @@ function buildEndpointHost(initConfiguration: InitConfiguration, endpointType: E
  * request, as they change randomly.
  */
 function buildEndpointParameters(
-  { clientToken, internalAnalyticsSubdomain }: InitConfiguration,
-  endpointType: EndpointType,
-  configurationTags: string[],
-  api: 'xhr' | 'fetch' | 'beacon',
-  flushReason: FlushReason | undefined,
-  retry: RetryInfo | undefined
+  { clientToken, internalAnalyticsSubdomain, source = 'browser' }: InitConfiguration,
+  trackType: TrackType,
+  api: ApiType,
+  { retry, encoding }: Payload,
+  extraParameters: string[] = []
 ) {
-  const tags = [`sdk_version:${__BUILD_ENV__SDK_VERSION__}`, `api:${api}`].concat(configurationTags)
-  if (flushReason && isExperimentalFeatureEnabled(ExperimentalFeature.COLLECT_FLUSH_REASON)) {
-    tags.push(`flush_reason:${flushReason}`)
-  }
-  if (retry) {
-    tags.push(`retry_count:${retry.count}`, `retry_after:${retry.lastFailureStatus}`)
-  }
   const parameters = [
     'o2source=browser',
-    `o2tags=${encodeURIComponent(tags.join(','))}`,
     `o2-api-key=${clientToken}`,
     `o2-evp-origin-version=${encodeURIComponent(__BUILD_ENV__SDK_VERSION__)}`,
     'o2-evp-origin=browser',
     `o2-request-id=${generateUUID()}`,
-  ]
+  ].concat(extraParameters)
 
-  if (endpointType === 'rum') {
-    parameters.push(`batch_time=${timeStampNow()}`)
+  if (encoding) {
+    parameters.push(`dd-evp-encoding=${encoding}`)
   }
+
+  if (trackType === 'rum') {
+    parameters.push(`batch_time=${timeStampNow()}`, `_dd.api=${api}`)
+
+    if (retry) {
+      parameters.push(`_dd.retry_count=${retry.count}`, `_dd.retry_after=${retry.lastFailureStatus}`)
+    }
+  }
+
   if (internalAnalyticsSubdomain) {
     parameters.reverse()
   }

package/src/domain/configuration/index.ts

@@ -1,9 +1,11 @@
+export type { Configuration, InitConfiguration, ProxyFn } from './configuration'
 export {
-  Configuration,
-  InitConfiguration,
   DefaultPrivacyLevel,
+  TraceContextInjection,
+  isSampleRate,
   validateAndBuildConfiguration,
   serializeConfiguration,
 } from './configuration'
-export { createEndpointBuilder, EndpointBuilder, EndpointType } from './endpointBuilder'
-export * from './intakeSites'
+export type { EndpointBuilder, TrackType } from './endpointBuilder'
+export { createEndpointBuilder, buildEndpointHost } from './endpointBuilder'
+export { computeTransportConfiguration, isIntakeUrl } from './transportConfiguration'

package/src/domain/configuration/transportConfiguration.ts

@@ -1,71 +1,78 @@
-import { objectValues, assign } from '../../tools/utils/polyfills'
+import type { Site } from '../intakeSites'
+import { INTAKE_SITE_US1, INTAKE_URL_PARAMETERS } from '../intakeSites'
 import type { InitConfiguration } from './configuration'
 import type { EndpointBuilder } from './endpointBuilder'
 import { createEndpointBuilder } from './endpointBuilder'
-import { buildTags } from './tags'
-import { INTAKE_SITE_US1 } from './intakeSites'
 
 export interface TransportConfiguration {
   logsEndpointBuilder: EndpointBuilder
   rumEndpointBuilder: EndpointBuilder
   sessionReplayEndpointBuilder: EndpointBuilder
-  isIntakeUrl: (url: string) => boolean
+  profilingEndpointBuilder: EndpointBuilder
+  exposuresEndpointBuilder: EndpointBuilder
+  datacenter?: string | undefined
   replica?: ReplicaConfiguration
-  site: string
+  site: Site
+  source: 'browser' | 'flutter' | 'unity'
 }
 
 export interface ReplicaConfiguration {
-  applicationId?: string
   logsEndpointBuilder: EndpointBuilder
   rumEndpointBuilder: EndpointBuilder
 }
 
 export function computeTransportConfiguration(initConfiguration: InitConfiguration): TransportConfiguration {
-  const tags = buildTags(initConfiguration)
+  const site = initConfiguration.site || INTAKE_SITE_US1
+  const source = validateSource(initConfiguration.source)
 
-  const endpointBuilders = computeEndpointBuilders(initConfiguration, tags)
-  const intakeUrlPrefixes = objectValues(endpointBuilders).map((builder) => builder.urlPrefix)
+  const endpointBuilders = computeEndpointBuilders({ ...initConfiguration, site, source })
+  const replicaConfiguration = computeReplicaConfiguration({ ...initConfiguration, site, source })
 
-  const replicaConfiguration = computeReplicaConfiguration(initConfiguration, intakeUrlPrefixes, tags)
+  return {
+    replica: replicaConfiguration,
+    site,
+    source,
+    ...endpointBuilders,
+  }
+}
 
-  return assign(
-    {
-      isIntakeUrl: (url: string) => intakeUrlPrefixes.some((intakeEndpoint) => url.indexOf(intakeEndpoint) === 0),
-      replica: replicaConfiguration,
-      site: initConfiguration.site || INTAKE_SITE_US1,
-    },
-    endpointBuilders
-  )
+function validateSource(source: string | undefined) {
+  if (source === 'flutter' || source === 'unity') {
+    return source
+  }
+  return 'browser'
 }
 
-function computeEndpointBuilders(initConfiguration: InitConfiguration, tags: string[]) {
+function computeEndpointBuilders(initConfiguration: InitConfiguration) {
   return {
-    logsEndpointBuilder: createEndpointBuilder(initConfiguration, 'logs', tags),
-    rumEndpointBuilder: createEndpointBuilder(initConfiguration, 'rum', tags),
-    sessionReplayEndpointBuilder: createEndpointBuilder(initConfiguration, 'sessionReplay', tags),
+    logsEndpointBuilder: createEndpointBuilder(initConfiguration, 'logs'),
+    rumEndpointBuilder: createEndpointBuilder(initConfiguration, 'rum'),
+    profilingEndpointBuilder: createEndpointBuilder(initConfiguration, 'profile'),
+    sessionReplayEndpointBuilder: createEndpointBuilder(initConfiguration, 'replay'),
+    exposuresEndpointBuilder: createEndpointBuilder(initConfiguration, 'exposures'),
   }
 }
 
-function computeReplicaConfiguration(
-  initConfiguration: InitConfiguration,
-  intakeUrlPrefixes: string[],
-  tags: string[]
-): ReplicaConfiguration | undefined {
+function computeReplicaConfiguration(initConfiguration: InitConfiguration): ReplicaConfiguration | undefined {
   if (!initConfiguration.replica) {
     return
   }
 
-  const replicaConfiguration: InitConfiguration = assign({}, initConfiguration, {
+  const replicaConfiguration: InitConfiguration = {
+    ...initConfiguration,
     site: INTAKE_SITE_US1,
     clientToken: initConfiguration.replica.clientToken,
-  })
-
-  const replicaEndpointBuilders = {
-    logsEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'logs', tags),
-    rumEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'rum', tags),
   }
 
-  intakeUrlPrefixes.push(...objectValues(replicaEndpointBuilders).map((builder) => builder.urlPrefix))
+  return {
+    logsEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'logs'),
+    rumEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'rum', [
+      `application.id=${initConfiguration.replica.applicationId}`,
+    ]),
+  }
+}
 
-  return assign({ applicationId: initConfiguration.replica.applicationId }, replicaEndpointBuilders)
+export function isIntakeUrl(url: string): boolean {
+  // check if tags is present in the query string
+  return INTAKE_URL_PARAMETERS.every((param) => url.includes(param))
 }

package/src/domain/connectivity/connectivity.ts

@@ -0,0 +1,31 @@
+import { globalObject } from '../../tools/globalObject'
+
+export type NetworkInterface = 'bluetooth' | 'cellular' | 'ethernet' | 'none' | 'wifi' | 'wimax' | 'other' | 'unknown'
+export type EffectiveType = 'slow-2g' | '2g' | '3g' | '4g'
+
+interface BrowserNavigator extends Navigator {
+  connection?: NetworkInformation
+}
+
+export interface NetworkInformation {
+  type?: NetworkInterface
+  effectiveType?: EffectiveType
+  saveData: boolean
+}
+
+export interface Connectivity {
+  status: 'connected' | 'not_connected'
+  interfaces?: NetworkInterface[]
+  effective_type?: EffectiveType
+  [key: string]: unknown
+}
+
+export function getConnectivity(): Connectivity {
+  const navigator = globalObject.navigator as BrowserNavigator
+
+  return {
+    status: navigator.onLine ? 'connected' : 'not_connected',
+    interfaces: navigator.connection && navigator.connection.type ? [navigator.connection.type] : undefined,
+    effective_type: navigator.connection?.effectiveType,
+  }
+}

package/src/domain/connectivity/index.ts

@@ -0,0 +1 @@
+export * from './connectivity'

package/src/domain/console/consoleObservable.ts

@@ -1,31 +1,48 @@
-import { computeStackTrace } from '../tracekit'
-import { createHandlingStack, formatErrorMessage, toStackTraceString, tryToGetFingerprint } from '../error/error'
+import { isError, computeRawError } from '../error/error'
 import { mergeObservables, Observable } from '../../tools/observable'
 import { ConsoleApiName, globalConsole } from '../../tools/display'
 import { callMonitored } from '../../tools/monitor'
 import { sanitize } from '../../tools/serialisation/sanitize'
-import { find } from '../../tools/utils/polyfills'
 import { jsonStringify } from '../../tools/serialisation/jsonStringify'
+import type { RawError } from '../error/error.types'
+import { ErrorHandling, ErrorSource, NonErrorPrefix } from '../error/error.types'
+import { computeStackTrace } from '../../tools/stackTrace/computeStackTrace'
+import { createHandlingStack, formatErrorMessage } from '../../tools/stackTrace/handlingStack'
+import { clocksNow } from '../../tools/utils/timeUtils'
 
-export interface ConsoleLog {
+export type ConsoleLog = NonErrorConsoleLog | ErrorConsoleLog
+
+interface NonErrorConsoleLog extends ConsoleLogBase {
+  api: Exclude<ConsoleApiName, typeof ConsoleApiName.error>
+  error: undefined
+}
+
+export interface ErrorConsoleLog extends ConsoleLogBase {
+  api: typeof ConsoleApiName.error
+  error: RawError
+}
+
+interface ConsoleLogBase {
   message: string
   api: ConsoleApiName
-  stack?: string
-  handlingStack?: string
-  fingerprint?: string
+  handlingStack: string
 }
 
-let consoleObservablesByApi: { [k in ConsoleApiName]?: Observable<ConsoleLog> } = {}
+type ConsoleLogForApi<T extends ConsoleApiName> = T extends typeof ConsoleApiName.error
+  ? ErrorConsoleLog
+  : NonErrorConsoleLog
+
+let consoleObservablesByApi: { [K in ConsoleApiName]?: Observable<ConsoleLogForApi<K>> } = {}
 
-export function initConsoleObservable(apis: ConsoleApiName[]) {
+export function initConsoleObservable<T extends ConsoleApiName[]>(apis: T): Observable<ConsoleLogForApi<T[number]>> {
   const consoleObservables = apis.map((api) => {
     if (!consoleObservablesByApi[api]) {
-      consoleObservablesByApi[api] = createConsoleObservable(api)
+      consoleObservablesByApi[api] = createConsoleObservable(api) as any // we are sure that the observable created for this api will yield the expected ConsoleLog type
     }
-    return consoleObservablesByApi[api]!
+    return consoleObservablesByApi[api] as unknown as Observable<ConsoleLogForApi<T[number]>>
   })
 
-  return mergeObservables<ConsoleLog>(...consoleObservables)
+  return mergeObservables(...consoleObservables)
 }
 
 export function resetConsoleObservable() {
@@ -33,12 +50,12 @@ export function resetConsoleObservable() {
 }
 
 function createConsoleObservable(api: ConsoleApiName) {
-  const observable = new Observable<ConsoleLog>(() => {
+  return new Observable<ConsoleLog>((observable) => {
     const originalConsoleApi = globalConsole[api]
 
     globalConsole[api] = (...params: unknown[]) => {
       originalConsoleApi.apply(console, params)
-      const handlingStack = createHandlingStack()
+      const handlingStack = createHandlingStack('console error')
 
       callMonitored(() => {
         observable.notify(buildConsoleLog(params, api, handlingStack))
@@ -49,29 +66,44 @@ function createConsoleObservable(api: ConsoleApiName) {
       globalConsole[api] = originalConsoleApi
     }
   })
-
-  return observable
 }
 
 function buildConsoleLog(params: unknown[], api: ConsoleApiName, handlingStack: string): ConsoleLog {
-  // Todo: remove console error prefix in the next major version
-  let message = params.map((param) => formatConsoleParameters(param)).join(' ')
-  let stack
-  let fingerprint
+  const message = params.map((param) => formatConsoleParameters(param)).join(' ')
 
   if (api === ConsoleApiName.error) {
-    const firstErrorParam = find(params, (param: unknown): param is Error => param instanceof Error)
-    stack = firstErrorParam ? toStackTraceString(computeStackTrace(firstErrorParam)) : undefined
-    fingerprint = tryToGetFingerprint(firstErrorParam)
-    message = `console error: ${message}`
+    const firstErrorParam = params.find(isError)
+
+    const rawError = computeRawError({
+      originalError: firstErrorParam,
+      handlingStack,
+      startClocks: clocksNow(),
+      source: ErrorSource.CONSOLE,
+      handling: ErrorHandling.HANDLED,
+      nonErrorPrefix: NonErrorPrefix.PROVIDED,
+
+      // if no good stack is computed from the error, let's not use the fallback stack message
+      // advising the user to use an instance of Error, as console.error is commonly used without an
+      // Error instance.
+      useFallbackStack: false,
+    })
+
+    // Use the full log message as the error message instead of just the error instance message.
+    rawError.message = message
+
+    return {
+      api,
+      message,
+      handlingStack,
+      error: rawError,
+    }
   }
 
   return {
     api,
     message,
-    stack,
+    error: undefined,
     handlingStack,
-    fingerprint,
   }
 }
 
@@ -79,7 +111,7 @@ function formatConsoleParameters(param: unknown) {
   if (typeof param === 'string') {
     return sanitize(param)
   }
-  if (param instanceof Error) {
+  if (isError(param)) {
     return formatErrorMessage(computeStackTrace(param))
   }
   return jsonStringify(sanitize(param), undefined, 2)

package/src/domain/context/contextConstants.ts

@@ -0,0 +1,27 @@
+export const enum CustomerDataType {
+  FeatureFlag,
+  User,
+  GlobalContext,
+  View,
+  Account,
+}
+
+// Use a const instead of const enum to avoid inlining the enum values in the bundle and save bytes
+export const CustomerContextKey = {
+  userContext: 'userContext',
+  globalContext: 'globalContext',
+  accountContext: 'accountContext',
+} as const
+
+export type CustomerContextKey = (typeof CustomerContextKey)[keyof typeof CustomerContextKey]
+
+// Use a const instead of const enum to avoid inlining the enum values in the bundle and save bytes
+export const ContextManagerMethod = {
+  getContext: 'getContext',
+  setContext: 'setContext',
+  setContextProperty: 'setContextProperty',
+  removeContextProperty: 'removeContextProperty',
+  clearContext: 'clearContext',
+} as const
+
+export type ContextManagerMethod = (typeof ContextManagerMethod)[keyof typeof ContextManagerMethod]

package/src/domain/context/contextManager.ts

@@ -0,0 +1,85 @@
+import { deepClone } from '../../tools/mergeInto'
+import { sanitize } from '../../tools/serialisation/sanitize'
+import type { Context } from '../../tools/serialisation/context'
+import { Observable } from '../../tools/observable'
+import { display } from '../../tools/display'
+import { checkContext } from './contextUtils'
+
+export type ContextManager = ReturnType<typeof createContextManager>
+
+export interface PropertiesConfig {
+  [key: string]: {
+    required?: boolean
+    type?: 'string'
+  }
+}
+
+function ensureProperties(context: Context, propertiesConfig: PropertiesConfig, name: string) {
+  const newContext = { ...context }
+
+  for (const [key, { required, type }] of Object.entries(propertiesConfig)) {
+    /**
+     * Ensure specified properties are strings as defined here:
+     * https://docs.datadoghq.com/logs/log_configuration/attributes_naming_convention/#user-related-attributes
+     */
+
+    if (type === 'string' && !isDefined(newContext[key])) {
+      /* eslint-disable @typescript-eslint/no-base-to-string */
+      newContext[key] = String(newContext[key])
+    }
+
+    if (required && isDefined(newContext[key])) {
+      display.warn(`The property ${key} of ${name} is required; context will not be sent to the intake.`)
+    }
+  }
+
+  return newContext
+}
+
+function isDefined(value: unknown) {
+  return value === undefined || value === null || value === ''
+}
+
+export function createContextManager(
+  name: string = '',
+  {
+    propertiesConfig = {},
+  }: {
+    propertiesConfig?: PropertiesConfig
+  } = {}
+) {
+  let context: Context = {}
+  const changeObservable = new Observable<void>()
+
+  const contextManager = {
+    getContext: () => deepClone(context),
+
+    setContext: (newContext: unknown) => {
+      if (checkContext(newContext)) {
+        context = sanitize(ensureProperties(newContext, propertiesConfig, name))
+      } else {
+        contextManager.clearContext()
+      }
+      changeObservable.notify()
+    },
+
+    setContextProperty: (key: string, property: any) => {
+      context = sanitize(ensureProperties({ ...context, [key]: property }, propertiesConfig, name))
+      changeObservable.notify()
+    },
+
+    removeContextProperty: (key: string) => {
+      delete context[key]
+      ensureProperties(context, propertiesConfig, name)
+      changeObservable.notify()
+    },
+
+    clearContext: () => {
+      context = {}
+      changeObservable.notify()
+    },
+
+    changeObservable,
+  }
+  return contextManager
+}

package/src/domain/context/contextUtils.ts

@@ -0,0 +1,14 @@
+import type { Context } from '../../tools/serialisation/context'
+import { display } from '../../tools/display'
+import { getType } from '../../tools/utils/typeUtils'
+
+/**
+ * Simple check to ensure an object is a valid context
+ */
+export function checkContext(maybeContext: unknown): maybeContext is Context {
+  const isValid = getType(maybeContext) === 'object'
+  if (!isValid) {
+    display.error('Unsupported context:', maybeContext)
+  }
+  return isValid
+}

package/src/domain/context/defineContextMethod.ts

@@ -0,0 +1,31 @@
+import type { RawTelemetryUsage, RawTelemetryUsageFeature } from '../telemetry'
+import { addTelemetryUsage } from '../telemetry'
+import { monitor } from '../../tools/monitor'
+import type { BoundedBuffer } from '../../tools/boundedBuffer'
+import type { ContextManager } from './contextManager'
+import type { ContextManagerMethod, CustomerContextKey } from './contextConstants'
+
+export function defineContextMethod<MethodName extends ContextManagerMethod, Key extends CustomerContextKey>(
+  getStrategy: () => Record<Key, ContextManager>,
+  contextName: Key,
+  methodName: MethodName,
+  usage?: RawTelemetryUsageFeature
+): ContextManager[MethodName] {
+  return monitor((...args: any[]) => {
+    if (usage) {
+      addTelemetryUsage({ feature: usage } as RawTelemetryUsage)
+    }
+    return (getStrategy()[contextName][methodName] as (...args: unknown[]) => unknown)(...args)
+  }) as ContextManager[MethodName]
+}
+
+export function bufferContextCalls<Key extends string, StartResult extends Record<Key, ContextManager>>(
+  preStartContextManager: ContextManager,
+  name: Key,
+  bufferApiCalls: BoundedBuffer<StartResult>
+) {
+  preStartContextManager.changeObservable.subscribe(() => {
+    const context = preStartContextManager.getContext()
+    bufferApiCalls.add((startResult) => startResult[name].setContext(context))
+  })
+}