@openobserve/browser-core 0.2.11-rc1 → 0.2.11

package/src/transport/batch.ts

@@ -2,24 +2,21 @@ import { display } from '../tools/display'
 import type { Context } from '../tools/serialisation/context'
 import { objectValues } from '../tools/utils/polyfills'
 import { isPageExitReason } from '../browser/pageExitObservable'
-import { jsonStringify } from '../tools/serialisation/jsonStringify'
-import type { Subscription } from '../tools/observable'
-import type { Encoder, EncoderResult } from '../tools/encoder'
 import { computeBytesCount } from '../tools/utils/byteUtils'
-import type { HttpRequest, Payload } from './httpRequest'
+import { jsonStringify } from '../tools/serialisation/jsonStringify'
+import type { HttpRequest } from './httpRequest'
 import type { FlushController, FlushEvent } from './flushController'
 
 export class Batch {
+  private pushOnlyBuffer: string[] = []
   private upsertBuffer: { [key: string]: string } = {}
-  private flushSubscription: Subscription
 
   constructor(
-    private encoder: Encoder,
     private request: HttpRequest,
     public flushController: FlushController,
     private messageBytesLimit: number
   ) {
-    this.flushSubscription = this.flushController.flushObservable.subscribe((event) => this.flush(event))
+    this.flushController.flushObservable.subscribe((event) => this.flush(event))
   }
 
   add(message: Context) {
@@ -30,57 +27,24 @@ export class Batch {
     this.addOrUpdate(message, key)
   }
 
-  stop() {
-    this.flushSubscription.unsubscribe()
-  }
-
   private flush(event: FlushEvent) {
-    const upsertMessages = objectValues(this.upsertBuffer).join('\n')
+    const messages = this.pushOnlyBuffer.concat(objectValues(this.upsertBuffer))
+
+    this.pushOnlyBuffer = []
     this.upsertBuffer = {}
 
-    const isPageExit = isPageExitReason(event.reason)
-    const send = isPageExit ? this.request.sendOnExit : this.request.send
-
-    if (
-      isPageExit &&
-      // Note: checking that the encoder is async is not strictly needed, but it's an optimization:
-      // if the encoder is async we need to send two requests in some cases (one for encoded data
-      // and the other for non-encoded data). But if it's not async, we don't have to worry about
-      // it and always send a single request.
-      this.encoder.isAsync
-    ) {
-      const encoderResult = this.encoder.finishSync()
-
-      // Send encoded messages
-      if (encoderResult.outputBytesCount) {
-        send(formatPayloadFromEncoder(encoderResult, event))
-      }
-
-      // Send messages that are not yet encoded at this point
-      const pendingMessages = [encoderResult.pendingData, upsertMessages].filter(Boolean).join('\n')
-      if (pendingMessages) {
-        send({
-          data: pendingMessages,
-          bytesCount: computeBytesCount(pendingMessages),
-          flushReason: event.reason,
-        })
-      }
+    const payload = { data: messages.join('\n'), bytesCount: event.bytesCount, flushReason: event.reason }
+    if (isPageExitReason(event.reason)) {
+      this.request.sendOnExit(payload)
     } else {
-      if (upsertMessages) {
-        this.encoder.write(this.encoder.isEmpty ? upsertMessages : `\n${upsertMessages}`)
-      }
-      this.encoder.finish((encoderResult) => {
-        send(formatPayloadFromEncoder(encoderResult, event))
-      })
+      this.request.send(payload)
     }
   }
 
   private addOrUpdate(message: Context, key?: string) {
-    const serializedMessage = jsonStringify(message)!
-
-    const estimatedMessageBytesCount = this.encoder.estimateEncodedBytesCount(serializedMessage)
+    const { processedMessage, messageBytesCount } = this.process(message)
 
-    if (estimatedMessageBytesCount >= this.messageBytesLimit) {
+    if (messageBytesCount >= this.messageBytesLimit) {
       display.warn(
         `Discarded a message whose size was bigger than the maximum allowed size ${this.messageBytesLimit}KB.`
       )
@@ -91,57 +55,38 @@ export class Batch {
       this.remove(key)
     }
 
-    this.push(serializedMessage, estimatedMessageBytesCount, key)
+    this.push(processedMessage, messageBytesCount, key)
+  }
+
+  private process(message: Context) {
+    const processedMessage = jsonStringify(message)!
+    const messageBytesCount = computeBytesCount(processedMessage)
+    return { processedMessage, messageBytesCount }
   }
 
-  private push(serializedMessage: string, estimatedMessageBytesCount: number, key?: string) {
-    this.flushController.notifyBeforeAddMessage(estimatedMessageBytesCount)
+  private push(processedMessage: string, messageBytesCount: number, key?: string) {
+    // If there are other messages, a '\n' will be added at serialization
+    const separatorBytesCount = this.flushController.messagesCount > 0 ? 1 : 0
 
+    this.flushController.notifyBeforeAddMessage(messageBytesCount + separatorBytesCount)
     if (key !== undefined) {
-      this.upsertBuffer[key] = serializedMessage
-      this.flushController.notifyAfterAddMessage()
+      this.upsertBuffer[key] = processedMessage
     } else {
-      this.encoder.write(
-        this.encoder.isEmpty ? serializedMessage : `\n${serializedMessage}`,
-        (realMessageBytesCount) => {
-          this.flushController.notifyAfterAddMessage(realMessageBytesCount - estimatedMessageBytesCount)
-        }
-      )
+      this.pushOnlyBuffer.push(processedMessage)
     }
+    this.flushController.notifyAfterAddMessage()
   }
 
   private remove(key: string) {
     const removedMessage = this.upsertBuffer[key]
     delete this.upsertBuffer[key]
-    const messageBytesCount = this.encoder.estimateEncodedBytesCount(removedMessage)
-    this.flushController.notifyAfterRemoveMessage(messageBytesCount)
+    const messageBytesCount = computeBytesCount(removedMessage)
+    // If there are other messages, a '\n' will be added at serialization
+    const separatorBytesCount = this.flushController.messagesCount > 1 ? 1 : 0
+    this.flushController.notifyAfterRemoveMessage(messageBytesCount + separatorBytesCount)
   }
 
   private hasMessageFor(key?: string): key is string {
     return key !== undefined && this.upsertBuffer[key] !== undefined
   }
 }
-
-function formatPayloadFromEncoder(encoderResult: EncoderResult, flushEvent: FlushEvent): Payload {
-  let data: string | Blob
-  if (typeof encoderResult.output === 'string') {
-    data = encoderResult.output
-  } else {
-    data = new Blob([encoderResult.output], {
-      // This will set the 'Content-Type: text/plain' header. Reasoning:
-      // * The intake rejects the request if there is no content type.
-      // * The browser will issue CORS preflight requests if we set it to 'application/json', which
-      // could induce higher intake load (and maybe has other impacts).
-      // * Also it's not quite JSON, since we are concatenating multiple JSON objects separated by
-      // new lines.
-      type: 'text/plain',
-    })
-  }
-
-  return {
-    data,
-    bytesCount: encoderResult.outputBytesCount,
-    encoding: encoderResult.encoding,
-    flushReason: flushEvent.reason,
-  }
-}

package/src/transport/flushController.ts

@@ -33,13 +33,10 @@ export function createFlushController({
   pageExitObservable,
   sessionExpireObservable,
 }: FlushControllerOptions) {
-  const pageExitSubscription = pageExitObservable.subscribe((event) => flush(event.reason))
-  const sessionExpireSubscription = sessionExpireObservable.subscribe(() => flush('session_expire'))
+  const flushObservable = new Observable<FlushEvent>()
 
-  const flushObservable = new Observable<FlushEvent>(() => () => {
-    pageExitSubscription.unsubscribe()
-    sessionExpireSubscription.unsubscribe()
-  })
+  pageExitObservable.subscribe((event) => flush(event.reason))
+  sessionExpireObservable.subscribe(() => flush('session_expire'))
 
   let currentBytesCount = 0
   let currentMessagesCount = 0
@@ -88,19 +85,16 @@ export function createFlushController({
      *
      * This function needs to be called synchronously, right before adding the message, so no flush
      * event can happen after `notifyBeforeAddMessage` and before adding the message.
-     *
-     * @param estimatedMessageBytesCount: an estimation of the message bytes count once it is
-     * actually added.
      */
-    notifyBeforeAddMessage(estimatedMessageBytesCount: number) {
-      if (currentBytesCount + estimatedMessageBytesCount >= bytesLimit) {
+    notifyBeforeAddMessage(messageBytesCount: number) {
+      if (currentBytesCount + messageBytesCount >= bytesLimit) {
         flush('bytes_limit')
       }
       // Consider the message to be added now rather than in `notifyAfterAddMessage`, because if no
       // message was added yet and `notifyAfterAddMessage` is called asynchronously, we still want
       // to notify when a flush is needed (for example on page exit).
       currentMessagesCount += 1
-      currentBytesCount += estimatedMessageBytesCount
+      currentBytesCount += messageBytesCount
       scheduleDurationLimitTimeout()
     },
 
@@ -109,13 +103,8 @@ export function createFlushController({
      *
      * This function can be called asynchronously after the message was added, but in this case it
      * should not be called if a flush event occurred in between.
-     *
-     * @param messageBytesCountDiff: the difference between the estimated message bytes count and
-     * its actual bytes count once added to the pool.
      */
-    notifyAfterAddMessage(messageBytesCountDiff = 0) {
-      currentBytesCount += messageBytesCountDiff
-
+    notifyAfterAddMessage() {
       if (currentMessagesCount >= messagesLimit) {
         flush('messages_limit')
       } else if (currentBytesCount >= bytesLimit) {
@@ -128,10 +117,6 @@ export function createFlushController({
      *
      * This function needs to be called synchronously, right after removing the message, so no flush
      * event can happen after removing the message and before `notifyAfterRemoveMessage`.
-     *
-     * @param messageBytesCount: the message bytes count that was added to the pool. Should
-     * correspond to the sum of bytes counts passed to `notifyBeforeAddMessage` and
-     * `notifyAfterAddMessage`.
      */
     notifyAfterRemoveMessage(messageBytesCount: number) {
       currentBytesCount -= messageBytesCount

package/src/transport/httpRequest.ts

@@ -24,11 +24,10 @@ export interface HttpResponse extends Context {
 }
 
 export interface Payload {
-  data: string | FormData | Blob
+  data: string | FormData
   bytesCount: number
   retry?: RetryInfo
   flushReason?: FlushReason
-  encoding?: 'deflate'
 }
 
 export interface RetryInfo {
@@ -48,7 +47,7 @@ export function createHttpRequest(
 
   return {
     send: (payload: Payload) => {
-      sendWithRetryStrategy(payload, retryState, sendStrategyForRetry, endpointBuilder.trackType, reportError)
+      sendWithRetryStrategy(payload, retryState, sendStrategyForRetry, endpointBuilder.endpointType, reportError)
     },
     /**
      * Since fetch keepalive behaves like regular fetch on Firefox,
@@ -64,13 +63,13 @@ function sendBeaconStrategy(
   configuration: Configuration,
   endpointBuilder: EndpointBuilder,
   bytesLimit: number,
-  payload: Payload
+  { data, bytesCount, flushReason }: Payload
 ) {
-  const canUseBeacon = !!navigator.sendBeacon && payload.bytesCount < bytesLimit
+  const canUseBeacon = !!navigator.sendBeacon && bytesCount < bytesLimit
   if (canUseBeacon) {
     try {
-      const beaconUrl = endpointBuilder.build('beacon', payload)
-      const isQueued = navigator.sendBeacon(beaconUrl, payload.data)
+      const beaconUrl = endpointBuilder.build('beacon', flushReason)
+      const isQueued = navigator.sendBeacon(beaconUrl, data)
 
       if (isQueued) {
         return
@@ -80,8 +79,8 @@ function sendBeaconStrategy(
     }
   }
 
-  const xhrUrl = endpointBuilder.build('xhr', payload)
-  sendXHR(configuration, xhrUrl, payload.data)
+  const xhrUrl = endpointBuilder.build('xhr', flushReason)
+  sendXHR(configuration, xhrUrl, data)
 }
 
 let hasReportedBeaconError = false
@@ -97,23 +96,23 @@ export function fetchKeepAliveStrategy(
   configuration: Configuration,
   endpointBuilder: EndpointBuilder,
   bytesLimit: number,
-  payload: Payload,
+  { data, bytesCount, flushReason, retry }: Payload,
   onResponse?: (r: HttpResponse) => void
 ) {
-  const canUseKeepAlive = isKeepAliveSupported() && payload.bytesCount < bytesLimit
+  const canUseKeepAlive = isKeepAliveSupported() && bytesCount < bytesLimit
   if (canUseKeepAlive) {
-    const fetchUrl = endpointBuilder.build('fetch', payload)
-    fetch(fetchUrl, { method: 'POST', body: payload.data, keepalive: true, mode: 'cors' }).then(
+    const fetchUrl = endpointBuilder.build('fetch', flushReason, retry)
+    fetch(fetchUrl, { method: 'POST', body: data, keepalive: true, mode: 'cors' }).then(
       monitor((response: Response) => onResponse?.({ status: response.status, type: response.type })),
       monitor(() => {
-        const xhrUrl = endpointBuilder.build('xhr', payload)
+        const xhrUrl = endpointBuilder.build('xhr', flushReason, retry)
         // failed to queue the request
-        sendXHR(configuration, xhrUrl, payload.data, onResponse)
+        sendXHR(configuration, xhrUrl, data, onResponse)
       })
     )
   } else {
-    const xhrUrl = endpointBuilder.build('xhr', payload)
-    sendXHR(configuration, xhrUrl, payload.data, onResponse)
+    const xhrUrl = endpointBuilder.build('xhr', flushReason, retry)
+    sendXHR(configuration, xhrUrl, data, onResponse)
   }
 }
 
@@ -134,12 +133,6 @@ export function sendXHR(
 ) {
   const request = new XMLHttpRequest()
   request.open('POST', url, true)
-  if (data instanceof Blob) {
-    // When using a Blob instance, IE does not use its 'type' to define the 'Content-Type' header
-    // automatically, so the intake request ends up being rejected with an HTTP status 415
-    // Defining the header manually fixes this issue.
-    request.setRequestHeader('Content-Type', data.type)
-  }
   addEventListener(
     configuration,
     request,

package/src/transport/sendWithRetryStrategy.ts

@@ -1,4 +1,4 @@
-import type { TrackType } from '../domain/configuration'
+import type { EndpointType } from '../domain/configuration'
 import { setTimeout } from '../tools/timer'
 import { clocksNow, ONE_MINUTE, ONE_SECOND } from '../tools/utils/timeUtils'
 import { ONE_MEBI_BYTE, ONE_KIBI_BYTE } from '../tools/utils/byteUtils'
@@ -38,7 +38,7 @@ export function sendWithRetryStrategy(
   payload: Payload,
   state: RetryState,
   sendStrategy: SendStrategy,
-  trackType: TrackType,
+  endpointType: EndpointType,
   reportError: (error: RawError) => void
 ) {
   if (
@@ -47,10 +47,10 @@ export function sendWithRetryStrategy(
     state.bandwidthMonitor.canHandle(payload)
   ) {
     send(payload, state, sendStrategy, {
-      onSuccess: () => retryQueuedPayloads(RetryReason.AFTER_SUCCESS, state, sendStrategy, trackType, reportError),
+      onSuccess: () => retryQueuedPayloads(RetryReason.AFTER_SUCCESS, state, sendStrategy, endpointType, reportError),
       onFailure: () => {
         state.queuedPayloads.enqueue(payload)
-        scheduleRetry(state, sendStrategy, trackType, reportError)
+        scheduleRetry(state, sendStrategy, endpointType, reportError)
       },
     })
   } else {
@@ -61,7 +61,7 @@ export function sendWithRetryStrategy(
 function scheduleRetry(
   state: RetryState,
   sendStrategy: SendStrategy,
-  trackType: TrackType,
+  endpointType: EndpointType,
   reportError: (error: RawError) => void
 ) {
   if (state.transportStatus !== TransportStatus.DOWN) {
@@ -73,11 +73,11 @@ function scheduleRetry(
       onSuccess: () => {
         state.queuedPayloads.dequeue()
         state.currentBackoffTime = INITIAL_BACKOFF_TIME
-        retryQueuedPayloads(RetryReason.AFTER_RESUME, state, sendStrategy, trackType, reportError)
+        retryQueuedPayloads(RetryReason.AFTER_RESUME, state, sendStrategy, endpointType, reportError)
       },
       onFailure: () => {
         state.currentBackoffTime = Math.min(MAX_BACKOFF_TIME, state.currentBackoffTime * 2)
-        scheduleRetry(state, sendStrategy, trackType, reportError)
+        scheduleRetry(state, sendStrategy, endpointType, reportError)
       },
     })
   }, state.currentBackoffTime)
@@ -112,12 +112,12 @@ function retryQueuedPayloads(
   reason: RetryReason,
   state: RetryState,
   sendStrategy: SendStrategy,
-  trackType: TrackType,
+  endpointType: EndpointType,
   reportError: (error: RawError) => void
 ) {
   if (reason === RetryReason.AFTER_SUCCESS && state.queuedPayloads.isFull() && !state.queueFullReported) {
     reportError({
-      message: `Reached max ${trackType} events size queued for upload: ${MAX_QUEUE_BYTES_COUNT / ONE_MEBI_BYTE}MiB`,
+      message: `Reached max ${endpointType} events size queued for upload: ${MAX_QUEUE_BYTES_COUNT / ONE_MEBI_BYTE}MiB`,
       source: ErrorSource.AGENT,
       startClocks: clocksNow(),
     })
@@ -126,7 +126,7 @@ function retryQueuedPayloads(
   const previousQueue = state.queuedPayloads
   state.queuedPayloads = newPayloadQueue()
   while (previousQueue.size() > 0) {
-    sendWithRetryStrategy(previousQueue.dequeue()!, state, sendStrategy, trackType, reportError)
+    sendWithRetryStrategy(previousQueue.dequeue()!, state, sendStrategy, endpointType, reportError)
   }
 }
 

package/src/transport/startBatchWithReplica.ts

@@ -3,35 +3,24 @@ 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,
+  primary: { endpoint: EndpointBuilder },
+  replica: { endpoint: EndpointBuilder; transformMessage?: (message: T) => T } | undefined,
   reportError: (error: RawError) => void,
   pageExitObservable: Observable<PageExitEvent>,
   sessionExpireObservable: Observable<void>
 ) {
-  const primaryBatch = createBatch(configuration, primary)
-  const replicaBatch = replica && createBatch(configuration, replica)
+  const primaryBatch = createBatch(configuration, primary.endpoint)
+  const replicaBatch = replica && createBatch(configuration, replica.endpoint)
 
-  function createBatch(configuration: Configuration, { endpoint, encoder }: BatchConfiguration) {
+  function createBatch(configuration: Configuration, endpointBuilder: EndpointBuilder) {
     return new Batch(
-      encoder,
-      createHttpRequest(configuration, endpoint, configuration.batchBytesLimit, reportError),
+      createHttpRequest(configuration, endpointBuilder, configuration.batchBytesLimit, reportError),
       createFlushController({
         messagesLimit: configuration.batchMessagesLimit,
         bytesLimit: configuration.batchBytesLimit,
@@ -59,10 +48,5 @@ export function startBatchWithReplica<T extends Context>(
         replicaBatch.upsert(replica.transformMessage ? replica.transformMessage(message) : message, key)
       }
     },
-
-    stop: () => {
-      primaryBatch.stop()
-      replicaBatch?.stop()
-    },
   }
 }

package/cjs/domain/connectivity/connectivity.d.ts

@@ -1,13 +0,0 @@
-export type NetworkInterface = 'bluetooth' | 'cellular' | 'ethernet' | 'none' | 'wifi' | 'wimax' | 'other' | 'unknown';
-export type EffectiveType = 'slow-2g' | '2g' | '3g' | '4g';
-export interface NetworkInformation {
-    type?: NetworkInterface;
-    effectiveType?: EffectiveType;
-}
-export interface Connectivity {
-    status: 'connected' | 'not_connected';
-    interfaces?: NetworkInterface[];
-    effective_type?: EffectiveType;
-    [key: string]: unknown;
-}
-export declare function getConnectivity(): Connectivity;

package/cjs/domain/connectivity/connectivity.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getConnectivity = void 0;
-function getConnectivity() {
-    var _a;
-    var navigator = window.navigator;
-    return {
-        status: navigator.onLine ? 'connected' : 'not_connected',
-        interfaces: navigator.connection && navigator.connection.type ? [navigator.connection.type] : undefined,
-        effective_type: (_a = navigator.connection) === null || _a === void 0 ? void 0 : _a.effectiveType,
-    };
-}
-exports.getConnectivity = getConnectivity;
-//# sourceMappingURL=connectivity.js.map

package/cjs/domain/connectivity/connectivity.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"connectivity.js","sourceRoot":"","sources":["../../../src/domain/connectivity/connectivity.ts"],"names":[],"mappings":";;;AAmBA,SAAgB,eAAe;;IAC7B,IAAM,SAAS,GAAG,MAAM,CAAC,SAA6B,CAAA;IACtD,OAAO;QACL,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,eAAe;QACxD,UAAU,EAAE,SAAS,CAAC,UAAU,IAAI,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS;QACvG,cAAc,EAAE,MAAA,SAAS,CAAC,UAAU,0CAAE,aAAa;KACpD,CAAA;AACH,CAAC;AAPD,0CAOC"}

package/cjs/domain/connectivity/index.d.ts

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

package/cjs/domain/connectivity/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/domain/connectivity/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,iDAA8B"}

package/cjs/domain/context/contextConstants.d.ts

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

package/cjs/domain/context/contextConstants.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"contextConstants.js","sourceRoot":"","sources":["../../../src/domain/context/contextConstants.ts"],"names":[],"mappings":""}

package/cjs/domain/context/contextManager.d.ts

@@ -1,12 +0,0 @@
-import type { Context } from '../../tools/serialisation/context';
-import { Observable } from '../../tools/observable';
-import type { CustomerDataTracker } from './customerDataTracker';
-export type ContextManager = ReturnType<typeof createContextManager>;
-export declare function createContextManager(customerDataTracker: CustomerDataTracker): {
-    getContext: () => Context;
-    setContext: (newContext: Context) => void;
-    setContextProperty: (key: string, property: any) => void;
-    removeContextProperty: (key: string) => void;
-    clearContext: () => void;
-    changeObservable: Observable<void>;
-};

package/cjs/domain/context/contextManager.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createContextManager = void 0;
-var mergeInto_1 = require("../../tools/mergeInto");
-var typeUtils_1 = require("../../tools/utils/typeUtils");
-var sanitize_1 = require("../../tools/serialisation/sanitize");
-var observable_1 = require("../../tools/observable");
-function createContextManager(customerDataTracker) {
-    var context = {};
-    var changeObservable = new observable_1.Observable();
-    var contextManager = {
-        getContext: function () { return (0, mergeInto_1.deepClone)(context); },
-        setContext: function (newContext) {
-            if ((0, typeUtils_1.getType)(newContext) === 'object') {
-                context = (0, sanitize_1.sanitize)(newContext);
-                customerDataTracker.updateCustomerData(context);
-            }
-            else {
-                contextManager.clearContext();
-            }
-            changeObservable.notify();
-        },
-        setContextProperty: function (key, property) {
-            context[key] = (0, sanitize_1.sanitize)(property);
-            customerDataTracker.updateCustomerData(context);
-            changeObservable.notify();
-        },
-        removeContextProperty: function (key) {
-            delete context[key];
-            customerDataTracker.updateCustomerData(context);
-            changeObservable.notify();
-        },
-        clearContext: function () {
-            context = {};
-            customerDataTracker.resetCustomerData();
-            changeObservable.notify();
-        },
-        changeObservable: changeObservable,
-    };
-    return contextManager;
-}
-exports.createContextManager = createContextManager;
-//# sourceMappingURL=contextManager.js.map

package/cjs/domain/context/contextManager.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"contextManager.js","sourceRoot":"","sources":["../../../src/domain/context/contextManager.ts"],"names":[],"mappings":";;;AAAA,mDAAiD;AACjD,yDAAqD;AACrD,+DAA6D;AAE7D,qDAAmD;AAKnD,SAAgB,oBAAoB,CAAC,mBAAwC;IAC3E,IAAI,OAAO,GAAY,EAAE,CAAA;IACzB,IAAM,gBAAgB,GAAG,IAAI,uBAAU,EAAQ,CAAA;IAE/C,IAAM,cAAc,GAAG;QACrB,UAAU,EAAE,cAAM,OAAA,IAAA,qBAAS,EAAC,OAAO,CAAC,EAAlB,CAAkB;QAEpC,UAAU,EAAE,UAAC,UAAmB;YAC9B,IAAI,IAAA,mBAAO,EAAC,UAAU,CAAC,KAAK,QAAQ,EAAE,CAAC;gBACrC,OAAO,GAAG,IAAA,mBAAQ,EAAC,UAAU,CAAC,CAAA;gBAC9B,mBAAmB,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAA;YACjD,CAAC;iBAAM,CAAC;gBACN,cAAc,CAAC,YAAY,EAAE,CAAA;YAC/B,CAAC;YACD,gBAAgB,CAAC,MAAM,EAAE,CAAA;QAC3B,CAAC;QAED,kBAAkB,EAAE,UAAC,GAAW,EAAE,QAAa;YAC7C,OAAO,CAAC,GAAG,CAAC,GAAG,IAAA,mBAAQ,EAAC,QAAQ,CAAC,CAAA;YACjC,mBAAmB,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAA;YAC/C,gBAAgB,CAAC,MAAM,EAAE,CAAA;QAC3B,CAAC;QAED,qBAAqB,EAAE,UAAC,GAAW;YACjC,OAAO,OAAO,CAAC,GAAG,CAAC,CAAA;YACnB,mBAAmB,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAA;YAC/C,gBAAgB,CAAC,MAAM,EAAE,CAAA;QAC3B,CAAC;QAED,YAAY,EAAE;YACZ,OAAO,GAAG,EAAE,CAAA;YACZ,mBAAmB,CAAC,iBAAiB,EAAE,CAAA;YACvC,gBAAgB,CAAC,MAAM,EAAE,CAAA;QAC3B,CAAC;QAED,gBAAgB,kBAAA;KACjB,CAAA;IACD,OAAO,cAAc,CAAA;AACvB,CAAC;AAtCD,oDAsCC"}

package/cjs/domain/context/customerDataTracker.d.ts

@@ -1,45 +0,0 @@
-import type { Context } from '../../tools/serialisation/context';
-import type { CustomerDataType } from './contextConstants';
-export declare const CUSTOMER_DATA_BYTES_LIMIT: number;
-export declare const CUSTOMER_COMPRESSED_DATA_BYTES_LIMIT: number;
-export declare const BYTES_COMPUTATION_THROTTLING_DELAY = 200;
-export type CustomerDataTracker = ReturnType<typeof createCustomerDataTracker>;
-export type CustomerDataTrackerManager = ReturnType<typeof createCustomerDataTrackerManager>;
-export declare const enum CustomerDataCompressionStatus {
-    Unknown = 0,
-    Enabled = 1,
-    Disabled = 2
-}
-export declare function createCustomerDataTrackerManager(compressionStatus?: CustomerDataCompressionStatus): {
-    /**
-     * 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: () => {
-        updateCustomerData: (context: Context) => void;
-        resetCustomerData: () => void;
-        getBytesCount: () => number;
-        stop: () => void;
-    };
-    /**
-     * Creates a tracker if it doesn't exist, and returns it.
-     */
-    getOrCreateTracker: (type: CustomerDataType) => {
-        updateCustomerData: (context: Context) => void;
-        resetCustomerData: () => void;
-        getBytesCount: () => number;
-        stop: () => void;
-    };
-    setCompressionStatus: (newCompressionStatus: CustomerDataCompressionStatus) => void;
-    getCompressionStatus: () => CustomerDataCompressionStatus;
-    stop: () => void;
-};
-export declare function createCustomerDataTracker(checkCustomerDataLimit: () => void): {
-    updateCustomerData: (context: Context) => void;
-    resetCustomerData: () => void;
-    getBytesCount: () => number;
-    stop: () => void;
-};