@openobserve/browser-core 0.2.9 → 0.2.11-rc1

package/src/browser/xhrObservable.ts

@@ -1,7 +1,8 @@
-import { instrumentMethodAndCallOriginal } from '../tools/instrumentMethod'
+import type { InstrumentedMethodCall } from '../tools/instrumentMethod'
+import { instrumentMethod } from '../tools/instrumentMethod'
 import { Observable } from '../tools/observable'
-import type { Duration, RelativeTime, ClocksState } from '../tools/utils/timeUtils'
-import { elapsed, relativeNow, clocksNow, timeStampNow } from '../tools/utils/timeUtils'
+import type { Duration, ClocksState } from '../tools/utils/timeUtils'
+import { elapsed, clocksNow, timeStampNow } from '../tools/utils/timeUtils'
 import { normalizeUrl } from '../tools/utils/urlPolyfill'
 import { shallowClone } from '../tools/utils/objectUtils'
 import type { Configuration } from '../domain/configuration'
@@ -15,7 +16,6 @@ export interface XhrOpenContext {
 
 export interface XhrStartContext extends Omit<XhrOpenContext, 'state'> {
   state: 'start'
-  startTime: RelativeTime // deprecated
   startClocks: ClocksState
   isAborted: boolean
   xhr: XMLHttpRequest
@@ -40,20 +40,14 @@ export function initXhrObservable(configuration: Configuration) {
 }
 
 function createXhrObservable(configuration: Configuration) {
-  const observable = new Observable<XhrContext>(() => {
-    const { stop: stopInstrumentingStart } = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'open', {
-      before: openXhr,
-    })
+  return new Observable<XhrContext>((observable) => {
+    const { stop: stopInstrumentingStart } = instrumentMethod(XMLHttpRequest.prototype, 'open', openXhr)
 
-    const { stop: stopInstrumentingSend } = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'send', {
-      before() {
-        sendXhr.call(this, configuration, observable)
-      },
+    const { stop: stopInstrumentingSend } = instrumentMethod(XMLHttpRequest.prototype, 'send', (call) => {
+      sendXhr(call, configuration, observable)
     })
 
-    const { stop: stopInstrumentingAbort } = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'abort', {
-      before: abortXhr,
-    })
+    const { stop: stopInstrumentingAbort } = instrumentMethod(XMLHttpRequest.prototype, 'abort', abortXhr)
 
     return () => {
       stopInstrumentingStart()
@@ -61,42 +55,42 @@ function createXhrObservable(configuration: Configuration) {
       stopInstrumentingAbort()
     }
   })
-  return observable
 }
 
-function openXhr(this: XMLHttpRequest, method: string, url: string | URL | undefined | null) {
-  xhrContexts.set(this, {
+function openXhr({ target: xhr, parameters: [method, url] }: InstrumentedMethodCall<XMLHttpRequest, 'open'>) {
+  xhrContexts.set(xhr, {
     state: 'open',
-    method,
+    method: String(method).toUpperCase(),
     url: normalizeUrl(String(url)),
   })
 }
 
-function sendXhr(this: XMLHttpRequest, configuration: Configuration, observable: Observable<XhrContext>) {
-  const context = xhrContexts.get(this)
+function sendXhr(
+  { target: xhr }: InstrumentedMethodCall<XMLHttpRequest, 'send'>,
+  configuration: Configuration,
+  observable: Observable<XhrContext>
+) {
+  const context = xhrContexts.get(xhr)
   if (!context) {
     return
   }
 
   const startContext = context as XhrStartContext
   startContext.state = 'start'
-  startContext.startTime = relativeNow()
   startContext.startClocks = clocksNow()
   startContext.isAborted = false
-  startContext.xhr = this
+  startContext.xhr = xhr
 
   let hasBeenReported = false
 
-  const { stop: stopInstrumentingOnReadyStateChange } = instrumentMethodAndCallOriginal(this, 'onreadystatechange', {
-    before() {
-      if (this.readyState === XMLHttpRequest.DONE) {
-        // Try to report the XHR as soon as possible, because the XHR may be mutated by the
-        // application during a future event. For example, Angular is calling .abort() on
-        // completed requests during a onreadystatechange event, so the status becomes '0'
-        // before the request is collected.
-        onEnd()
-      }
-    },
+  const { stop: stopInstrumentingOnReadyStateChange } = instrumentMethod(xhr, 'onreadystatechange', () => {
+    if (xhr.readyState === XMLHttpRequest.DONE) {
+      // Try to report the XHR as soon as possible, because the XHR may be mutated by the
+      // application during a future event. For example, Angular is calling .abort() on
+      // completed requests during an onreadystatechange event, so the status becomes '0'
+      // before the request is collected.
+      onEnd()
+    }
   })
 
   const onEnd = () => {
@@ -110,17 +104,17 @@ function sendXhr(this: XMLHttpRequest, configuration: Configuration, observable:
     const completeContext = context as XhrCompleteContext
     completeContext.state = 'complete'
     completeContext.duration = elapsed(startContext.startClocks.timeStamp, timeStampNow())
-    completeContext.status = this.status
+    completeContext.status = xhr.status
     observable.notify(shallowClone(completeContext))
   }
 
-  const { stop: unsubscribeLoadEndListener } = addEventListener(configuration, this, 'loadend', onEnd)
+  const { stop: unsubscribeLoadEndListener } = addEventListener(configuration, xhr, 'loadend', onEnd)
 
   observable.notify(startContext)
 }
 
-function abortXhr(this: XMLHttpRequest) {
-  const context = xhrContexts.get(this) as XhrStartContext | undefined
+function abortXhr({ target: xhr }: InstrumentedMethodCall<XMLHttpRequest, 'abort'>) {
+  const context = xhrContexts.get(xhr) as XhrStartContext | undefined
   if (context) {
     context.isAborted = true
   }

package/src/domain/configuration/configuration.ts

@@ -24,22 +24,15 @@ export interface InitConfiguration {
   // global options
   clientToken: string
   beforeSend?: GenericBeforeSendCallback | undefined
-  /**
-   * @deprecated use sessionSampleRate instead
-   */
-  sampleRate?: number | undefined
   sessionSampleRate?: number | undefined
   telemetrySampleRate?: number | undefined
   silentMultipleInit?: boolean | undefined
-  trackResources?: boolean | undefined
-  trackLongTasks?: boolean | undefined
+  allowFallbackToLocalStorage?: boolean | undefined
+  allowUntrustedEvents?: boolean | undefined
+  storeContextsAcrossPages?: boolean | undefined
 
   // transport options
-  proxy?: string | undefined
-  /**
-   * @deprecated use `proxy` instead
-   */
-  proxyUrl?: string | undefined
+  proxy?: string | ProxyFn | undefined
   site?: string | undefined
 
   // tag and context options
@@ -48,17 +41,19 @@ export interface InitConfiguration {
   version: string | undefined
 
   // cookie options
+  /**
+   * @deprecated use usePartitionedCrossSiteSessionCookie instead
+   */
   useCrossSiteSessionCookie?: boolean | undefined
+  usePartitionedCrossSiteSessionCookie?: boolean | undefined
   useSecureSessionCookie?: boolean | undefined
   trackSessionAcrossSubdomains?: boolean | undefined
 
-  // alternate storage option
-  allowFallbackToLocalStorage?: boolean | undefined
-
   // internal options
   enableExperimentalFeatures?: string[] | undefined
   replica?: ReplicaUserConfiguration | undefined
   datacenter?: string
+  // TODO next major: remove this option and replace usages by proxyFn
   internalAnalyticsSubdomain?: string
 
   telemetryConfigurationSampleRate?: number
@@ -72,6 +67,12 @@ export interface InitConfiguration {
 // for this option.
 type GenericBeforeSendCallback = (event: any, context?: any) => unknown
 
+/**
+ * path: /api/vX/product
+ * parameters: xxx=yyy&zzz=aaa
+ */
+type ProxyFn = (options: { path: string; parameters: string }) => string
+
 interface ReplicaUserConfiguration {
   applicationId?: string
   clientToken: string
@@ -86,6 +87,7 @@ export interface Configuration extends TransportConfiguration {
   telemetryConfigurationSampleRate: number
   service: string | undefined
   silentMultipleInit: boolean
+  allowUntrustedEvents: boolean
 
   // Event limits
   eventRateLimiterThreshold: number // Limit the maximum number of actions, errors and logs per minutes
@@ -104,8 +106,7 @@ export function validateAndBuildConfiguration(initConfiguration: InitConfigurati
     return
   }
 
-  const sessionSampleRate = initConfiguration.sessionSampleRate ?? initConfiguration.sampleRate
-  if (sessionSampleRate !== undefined && !isPercentage(sessionSampleRate)) {
+  if (initConfiguration.sessionSampleRate !== undefined && !isPercentage(initConfiguration.sessionSampleRate)) {
     display.error('Session Sample Rate should be a number between 0 and 100')
     return
   }
@@ -137,11 +138,12 @@ export function validateAndBuildConfiguration(initConfiguration: InitConfigurati
       beforeSend:
         initConfiguration.beforeSend && catchUserErrors(initConfiguration.beforeSend, 'beforeSend threw an error:'),
       sessionStoreStrategyType: selectSessionStoreStrategyType(initConfiguration),
-      sessionSampleRate: sessionSampleRate ?? 100,
+      sessionSampleRate: initConfiguration.sessionSampleRate ?? 100,
       telemetrySampleRate: initConfiguration.telemetrySampleRate ?? 20,
       telemetryConfigurationSampleRate: initConfiguration.telemetryConfigurationSampleRate ?? 5,
       service: initConfiguration.service,
       silentMultipleInit: !!initConfiguration.silentMultipleInit,
+      allowUntrustedEvents: !!initConfiguration.allowUntrustedEvents,
 
       /**
        * beacon payload max queue size implementation is 64kb
@@ -173,19 +175,19 @@ export function validateAndBuildConfiguration(initConfiguration: InitConfigurati
 }
 
 export function serializeConfiguration(initConfiguration: InitConfiguration): Partial<RawTelemetryConfiguration> {
-  const proxy = initConfiguration.proxy ?? initConfiguration.proxyUrl
   return {
-    session_sample_rate: initConfiguration.sessionSampleRate ?? initConfiguration.sampleRate,
+    session_sample_rate: initConfiguration.sessionSampleRate,
     telemetry_sample_rate: initConfiguration.telemetrySampleRate,
     telemetry_configuration_sample_rate: initConfiguration.telemetryConfigurationSampleRate,
     use_before_send: !!initConfiguration.beforeSend,
     use_cross_site_session_cookie: initConfiguration.useCrossSiteSessionCookie,
+    use_partitioned_cross_site_session_cookie: initConfiguration.usePartitionedCrossSiteSessionCookie,
     use_secure_session_cookie: initConfiguration.useSecureSessionCookie,
-    use_proxy: proxy !== undefined ? !!proxy : undefined,
+    use_proxy: !!initConfiguration.proxy,
     silent_multiple_init: initConfiguration.silentMultipleInit,
     track_session_across_subdomains: initConfiguration.trackSessionAcrossSubdomains,
-    track_resources: initConfiguration.trackResources,
-    track_long_task: initConfiguration.trackLongTasks,
     allow_fallback_to_local_storage: !!initConfiguration.allowFallbackToLocalStorage,
+    store_contexts_across_pages: !!initConfiguration.storeContextsAcrossPages,
+    allow_untrusted_events: !!initConfiguration.allowUntrustedEvents,
   }
 }

package/src/domain/configuration/endpointBuilder.ts

@@ -1,51 +1,39 @@
-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 type { InitConfiguration } from './configuration'
-import { INTAKE_SITE_AP1, INTAKE_SITE_US1 } from './intakeSites'
+import { 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'
+export type ApiType =
+  | 'xhr'
+  | '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,
+  trackType: TrackType,
   configurationTags: 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, configurationTags, api, payload)
       return buildUrlWithParameters(parameters)
     },
     urlPrefix: buildUrlWithParameters(''),
-    endpointType,
+    trackType,
   }
 }
 
@@ -56,35 +44,29 @@ export function createEndpointBuilder(
  */
 function createEndpointUrlWithParametersBuilder(
   initConfiguration: InitConfiguration,
-  endpointType: EndpointType
+  trackType: TrackType
 ): (parameters: string) => string {
-  const { proxy, proxyUrl, apiVersion, organizationIdentifier, insecureHTTP } = initConfiguration
+  const { proxy, apiVersion, organizationIdentifier, insecureHTTP } = initConfiguration
 
-  const path = `/rum/${apiVersion}/${organizationIdentifier}/${INTAKE_TRACKS[endpointType]}`
+  const path = `/rum/${apiVersion}/${organizationIdentifier}/${trackType}`
 
   if (proxy) {
     const normalizedProxyUrl = normalizeUrl(proxy)
-    return (parameters) => `${normalizedProxyUrl}?ooforward=${encodeURIComponent(`${path}?${parameters}`)}`
+    return (parameters) => `${normalizedProxyUrl}?o2forward=${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 host = buildEndpointHost(initConfiguration)
   const protocol = insecureHTTP ? 'http' : 'https'
 
   return (parameters) => `${protocol}://${host}${path}?${parameters}`
 }
 
-function buildEndpointHost(initConfiguration: InitConfiguration, endpointType: EndpointType) {
+function buildEndpointHost(initConfiguration: InitConfiguration) {
   const { site = INTAKE_SITE_US1, internalAnalyticsSubdomain } = initConfiguration
 
-  return site;
+  return site
   if (internalAnalyticsSubdomain && site === INTAKE_SITE_US1) {
     return `${internalAnalyticsSubdomain}.${INTAKE_SITE_US1}`
   }
@@ -101,11 +83,10 @@ function buildEndpointHost(initConfiguration: InitConfiguration, endpointType: E
  */
 function buildEndpointParameters(
   { clientToken, internalAnalyticsSubdomain }: InitConfiguration,
-  endpointType: EndpointType,
+  trackType: TrackType,
   configurationTags: string[],
-  api: 'xhr' | 'fetch' | 'beacon',
-  flushReason: FlushReason | undefined,
-  retry: RetryInfo | undefined
+  api: ApiType,
+  { retry, flushReason, encoding }: Payload
 ) {
   const tags = [`sdk_version:${__BUILD_ENV__SDK_VERSION__}`, `api:${api}`].concat(configurationTags)
   if (flushReason && isExperimentalFeatureEnabled(ExperimentalFeature.COLLECT_FLUSH_REASON)) {
@@ -114,18 +95,24 @@ function buildEndpointParameters(
   if (retry) {
     tags.push(`retry_count:${retry.count}`, `retry_after:${retry.lastFailureStatus}`)
   }
+
   const parameters = [
-    'oosource=browser',
-    `ootags=${encodeURIComponent(tags.join(','))}`,
-    `oo-api-key=${clientToken}`,
-    `oo-evp-origin-version=${encodeURIComponent(__BUILD_ENV__SDK_VERSION__)}`,
-    'oo-evp-origin=browser',
-    `oo-request-id=${generateUUID()}`,
+    '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()}`,
   ]
 
-  if (endpointType === 'rum') {
+  if (encoding) {
+    parameters.push(`o2-evp-encoding=${encoding}`)
+  }
+
+  if (trackType === 'rum') {
     parameters.push(`batch_time=${timeStampNow()}`)
   }
+
   if (internalAnalyticsSubdomain) {
     parameters.reverse()
   }

package/src/domain/configuration/index.ts

@@ -5,5 +5,6 @@ export {
   validateAndBuildConfiguration,
   serializeConfiguration,
 } from './configuration'
-export { createEndpointBuilder, EndpointBuilder, EndpointType } from './endpointBuilder'
+export { createEndpointBuilder, EndpointBuilder, TrackType } from './endpointBuilder'
 export * from './intakeSites'
+export { computeTransportConfiguration } from './transportConfiguration'

package/src/domain/configuration/transportConfiguration.ts

@@ -42,7 +42,7 @@ function computeEndpointBuilders(initConfiguration: InitConfiguration, tags: str
   return {
     logsEndpointBuilder: createEndpointBuilder(initConfiguration, 'logs', tags),
     rumEndpointBuilder: createEndpointBuilder(initConfiguration, 'rum', tags),
-    sessionReplayEndpointBuilder: createEndpointBuilder(initConfiguration, 'sessionReplay', tags),
+    sessionReplayEndpointBuilder: createEndpointBuilder(initConfiguration, 'replay', tags),
   }
 }
 

package/src/domain/connectivity/connectivity.ts

@@ -0,0 +1,27 @@
+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
+}
+
+export interface Connectivity {
+  status: 'connected' | 'not_connected'
+  interfaces?: NetworkInterface[]
+  effective_type?: EffectiveType
+  [key: string]: unknown
+}
+
+export function getConnectivity(): Connectivity {
+  const navigator = window.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,4 +1,3 @@
-import { computeStackTrace } from '../tracekit'
 import { createHandlingStack, formatErrorMessage, toStackTraceString, tryToGetFingerprint } from '../error/error'
 import { mergeObservables, Observable } from '../../tools/observable'
 import { ConsoleApiName, globalConsole } from '../../tools/display'
@@ -6,6 +5,7 @@ import { callMonitored } from '../../tools/monitor'
 import { sanitize } from '../../tools/serialisation/sanitize'
 import { find } from '../../tools/utils/polyfills'
 import { jsonStringify } from '../../tools/serialisation/jsonStringify'
+import { computeStackTrace } from '../error/computeStackTrace'
 
 export interface ConsoleLog {
   message: string
@@ -33,7 +33,7 @@ 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[]) => {
@@ -49,13 +49,10 @@ 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(' ')
+  const message = params.map((param) => formatConsoleParameters(param)).join(' ')
   let stack
   let fingerprint
 
@@ -63,7 +60,6 @@ function buildConsoleLog(params: unknown[], api: ConsoleApiName, handlingStack:
     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}`
   }
 
   return {

package/src/domain/context/contextConstants.ts

@@ -0,0 +1,5 @@
+export const enum CustomerDataType {
+  FeatureFlag,
+  User,
+  GlobalContext,
+}

package/src/domain/context/contextManager.ts

@@ -0,0 +1,48 @@
+import { deepClone } from '../../tools/mergeInto'
+import { getType } from '../../tools/utils/typeUtils'
+import { sanitize } from '../../tools/serialisation/sanitize'
+import type { Context } from '../../tools/serialisation/context'
+import { Observable } from '../../tools/observable'
+import type { CustomerDataTracker } from './customerDataTracker'
+
+export type ContextManager = ReturnType<typeof createContextManager>
+
+export function createContextManager(customerDataTracker: CustomerDataTracker) {
+  let context: Context = {}
+  const changeObservable = new Observable<void>()
+
+  const contextManager = {
+    getContext: () => deepClone(context),
+
+    setContext: (newContext: Context) => {
+      if (getType(newContext) === 'object') {
+        context = sanitize(newContext)
+        customerDataTracker.updateCustomerData(context)
+      } else {
+        contextManager.clearContext()
+      }
+      changeObservable.notify()
+    },
+
+    setContextProperty: (key: string, property: any) => {
+      context[key] = sanitize(property)
+      customerDataTracker.updateCustomerData(context)
+      changeObservable.notify()
+    },
+
+    removeContextProperty: (key: string) => {
+      delete context[key]
+      customerDataTracker.updateCustomerData(context)
+      changeObservable.notify()
+    },
+
+    clearContext: () => {
+      context = {}
+      customerDataTracker.resetCustomerData()
+      changeObservable.notify()
+    },
+
+    changeObservable,
+  }
+  return contextManager
+}