@openobserve/browser-core 0.2.11-rc1 → 0.2.12-beta.1

package/src/domain/context/customerDataTracker.ts

@@ -1,134 +0,0 @@
-import { ONE_KIBI_BYTE, computeBytesCount } from '../../tools/utils/byteUtils'
-import { throttle } from '../../tools/utils/functionUtils'
-import type { Context } from '../../tools/serialisation/context'
-import { jsonStringify } from '../../tools/serialisation/jsonStringify'
-import { display } from '../../tools/display'
-import { isEmptyObject } from '../../tools/utils/objectUtils'
-import type { CustomerDataType } from './contextConstants'
-
-// RUM and logs batch bytes limit is 16KB
-// ensure that we leave room for other event attributes and maintain a decent amount of event per batch
-// (3KB (customer data) + 1KB (other attributes)) * 4 (events per batch) = 16KB
-export const CUSTOMER_DATA_BYTES_LIMIT = 3 * ONE_KIBI_BYTE
-
-// We observed that the compression ratio is around 8 in general, but we also want to keep a margin
-// because some data might not be compressed (ex: last view update on page exit). We chose 16KiB
-// because it is also the limit of the 'batchBytesCount' that we use for RUM and Logs data, but this
-// is a bit arbitrary.
-export const CUSTOMER_COMPRESSED_DATA_BYTES_LIMIT = 16 * ONE_KIBI_BYTE
-
-export const BYTES_COMPUTATION_THROTTLING_DELAY = 200
-
-export type CustomerDataTracker = ReturnType<typeof createCustomerDataTracker>
-export type CustomerDataTrackerManager = ReturnType<typeof createCustomerDataTrackerManager>
-
-export const enum CustomerDataCompressionStatus {
-  Unknown,
-  Enabled,
-  Disabled,
-}
-
-export function createCustomerDataTrackerManager(
-  compressionStatus: CustomerDataCompressionStatus = CustomerDataCompressionStatus.Disabled
-) {
-  const customerDataTrackers = new Map<CustomerDataType, CustomerDataTracker>()
-
-  let alreadyWarned = false
-  function checkCustomerDataLimit(initialBytesCount = 0) {
-    if (alreadyWarned || compressionStatus === CustomerDataCompressionStatus.Unknown) {
-      return
-    }
-
-    const bytesCountLimit =
-      compressionStatus === CustomerDataCompressionStatus.Disabled
-        ? CUSTOMER_DATA_BYTES_LIMIT
-        : CUSTOMER_COMPRESSED_DATA_BYTES_LIMIT
-
-    let bytesCount = initialBytesCount
-    customerDataTrackers.forEach((tracker) => {
-      bytesCount += tracker.getBytesCount()
-    })
-
-    if (bytesCount > bytesCountLimit) {
-      displayCustomerDataLimitReachedWarning(bytesCountLimit)
-      alreadyWarned = true
-    }
-  }
-
-  return {
-    /**
-     * Creates a detached tracker. The manager will not store a reference to that tracker, and the
-     * bytes count will be counted independently from other detached trackers.
-     *
-     * This is particularly useful when we don't know when the tracker will be unused, so we don't
-     * leak memory (ex: when used in Logger instances).
-     */
-    createDetachedTracker: () => {
-      const tracker = createCustomerDataTracker(() => checkCustomerDataLimit(tracker.getBytesCount()))
-      return tracker
-    },
-
-    /**
-     * Creates a tracker if it doesn't exist, and returns it.
-     */
-    getOrCreateTracker: (type: CustomerDataType) => {
-      if (!customerDataTrackers.has(type)) {
-        customerDataTrackers.set(type, createCustomerDataTracker(checkCustomerDataLimit))
-      }
-      return customerDataTrackers.get(type)!
-    },
-
-    setCompressionStatus: (newCompressionStatus: CustomerDataCompressionStatus) => {
-      if (compressionStatus === CustomerDataCompressionStatus.Unknown) {
-        compressionStatus = newCompressionStatus
-        checkCustomerDataLimit()
-      }
-    },
-
-    getCompressionStatus: () => compressionStatus,
-
-    stop: () => {
-      customerDataTrackers.forEach((tracker) => tracker.stop())
-      customerDataTrackers.clear()
-    },
-  }
-}
-
-export function createCustomerDataTracker(checkCustomerDataLimit: () => void) {
-  let bytesCountCache = 0
-
-  // Throttle the bytes computation to minimize the impact on performance.
-  // Especially useful if the user call context APIs synchronously multiple times in a row
-  const { throttled: computeBytesCountThrottled, cancel: cancelComputeBytesCount } = throttle((context: Context) => {
-    bytesCountCache = computeBytesCount(jsonStringify(context)!)
-    checkCustomerDataLimit()
-  }, BYTES_COMPUTATION_THROTTLING_DELAY)
-
-  const resetBytesCount = () => {
-    cancelComputeBytesCount()
-    bytesCountCache = 0
-  }
-
-  return {
-    updateCustomerData: (context: Context) => {
-      if (isEmptyObject(context)) {
-        resetBytesCount()
-      } else {
-        computeBytesCountThrottled(context)
-      }
-    },
-    resetCustomerData: resetBytesCount,
-    getBytesCount: () => bytesCountCache,
-    stop: () => {
-      cancelComputeBytesCount()
-    },
-  }
-}
-
-function displayCustomerDataLimitReachedWarning(bytesCountLimit: number) {
-  display.warn(
-    `Customer data exceeds the recommended ${
-      bytesCountLimit / ONE_KIBI_BYTE
-    }KiB threshold. More details: https://docs.datadoghq.com/real_user_monitoring/browser/troubleshooting/#customer-data-exceeds-the-recommended-threshold-warning`
-  )
-}

package/src/domain/user/index.ts

@@ -1,2 +0,0 @@
-export * from './user.types'
-export * from './user'

package/src/domain/user/user.ts

@@ -1,33 +0,0 @@
-import type { Context } from '../../tools/serialisation/context'
-import { display } from '../../tools/display'
-import { getType } from '../../tools/utils/typeUtils'
-import { assign } from '../../tools/utils/polyfills'
-import type { User } from './user.types'
-
-/**
- * Clone input data and ensure known user properties (id, name, email)
- * are strings, as defined here:
- * https://docs.datadoghq.com/logs/log_configuration/attributes_naming_convention/#user-related-attributes
- */
-export function sanitizeUser(newUser: Context): Context {
-  // We shallow clone only to prevent mutation of user data.
-  const user = assign({}, newUser)
-  const keys = ['id', 'name', 'email']
-  keys.forEach((key) => {
-    if (key in user) {
-      user[key] = String(user[key])
-    }
-  })
-  return user
-}
-
-/**
- * Simple check to ensure user is valid
- */
-export function checkUser(newUser: User): boolean {
-  const isValid = getType(newUser) === 'object'
-  if (!isValid) {
-    display.error('Unsupported user:', newUser)
-  }
-  return isValid
-}

package/src/domain/user/user.types.ts

@@ -1,6 +0,0 @@
-export interface User {
-  id?: string | undefined
-  email?: string | undefined
-  name?: string | undefined
-  [key: string]: unknown
-}

package/src/transport/startBatchWithReplica.ts

@@ -1,68 +0,0 @@
-import type { Configuration, EndpointBuilder } from '../domain/configuration'
-import type { Context } from '../tools/serialisation/context'
-import type { Observable } from '../tools/observable'
-import type { PageExitEvent } from '../browser/pageExitObservable'
-import type { RawError } from '../domain/error/error.types'
-import type { Encoder } from '../tools/encoder'
-import { Batch } from './batch'
-import { createHttpRequest } from './httpRequest'
-import { createFlushController } from './flushController'
-
-export interface BatchConfiguration {
-  endpoint: EndpointBuilder
-  encoder: Encoder
-}
-
-interface ReplicaBatchConfiguration<T> extends BatchConfiguration {
-  transformMessage?: (message: T) => T
-}
-
-export function startBatchWithReplica<T extends Context>(
-  configuration: Configuration,
-  primary: BatchConfiguration,
-  replica: ReplicaBatchConfiguration<T> | undefined,
-  reportError: (error: RawError) => void,
-  pageExitObservable: Observable<PageExitEvent>,
-  sessionExpireObservable: Observable<void>
-) {
-  const primaryBatch = createBatch(configuration, primary)
-  const replicaBatch = replica && createBatch(configuration, replica)
-
-  function createBatch(configuration: Configuration, { endpoint, encoder }: BatchConfiguration) {
-    return new Batch(
-      encoder,
-      createHttpRequest(configuration, endpoint, configuration.batchBytesLimit, reportError),
-      createFlushController({
-        messagesLimit: configuration.batchMessagesLimit,
-        bytesLimit: configuration.batchBytesLimit,
-        durationLimit: configuration.flushTimeout,
-        pageExitObservable,
-        sessionExpireObservable,
-      }),
-      configuration.messageBytesLimit
-    )
-  }
-
-  return {
-    flushObservable: primaryBatch.flushController.flushObservable,
-
-    add(message: T, replicated = true) {
-      primaryBatch.add(message)
-      if (replicaBatch && replicated) {
-        replicaBatch.add(replica.transformMessage ? replica.transformMessage(message) : message)
-      }
-    },
-
-    upsert: (message: T, key: string) => {
-      primaryBatch.upsert(message, key)
-      if (replicaBatch) {
-        replicaBatch.upsert(replica.transformMessage ? replica.transformMessage(message) : message, key)
-      }
-    },
-
-    stop: () => {
-      primaryBatch.stop()
-      replicaBatch?.stop()
-    },
-  }
-}