@openobserve/browser-core 0.3.4 → 0.4.0-beta.1

package/esm/transport/flushController.mjs

@@ -0,0 +1,104 @@
+import { isWorkerEnvironment } from "../tools/globalObject.mjs";
+import { Observable } from "../tools/observable.mjs";
+import { clearTimeout, setTimeout } from "../tools/timer.mjs";
+import { RECOMMENDED_REQUEST_BYTES_LIMIT } from "./httpRequest.mjs";
+import { ONE_SECOND } from "@openobserve/js-core/time";
+//#region src/transport/flushController.ts
+/**
+* flush automatically, aim to be lower than ALB connection timeout
+* to maximize connection reuse.
+*/
+const FLUSH_DURATION_LIMIT = 30 * ONE_SECOND;
+/**
+* When using the SDK in a Worker Environment, we limit the batch size to 1 to ensure it can be sent
+* in a single event.
+*/
+const MESSAGES_LIMIT = isWorkerEnvironment ? 1 : 50;
+/**
+* Returns a "flush controller", responsible of notifying when flushing a pool of pending data needs
+* to happen. The implementation is designed to support both synchronous and asynchronous usages,
+* but relies on invariants described in each method documentation to keep a coherent state.
+*/
+function createFlushController({ pageMayExitObservable, sessionExpireObservable }) {
+	let forcedFlushReason;
+	const preparePageExitFlushObservable = new Observable();
+	const pageMayExitSubscription = pageMayExitObservable.subscribe((event) => {
+		forcedFlushReason = event.reason;
+		try {
+			preparePageExitFlushObservable.notify(event.reason);
+		} finally {
+			forcedFlushReason = void 0;
+		}
+		flush(event.reason);
+	});
+	const sessionExpireSubscription = sessionExpireObservable.subscribe(() => flush("session_expire"));
+	const flushObservable = new Observable(() => () => {
+		pageMayExitSubscription.unsubscribe();
+		sessionExpireSubscription.unsubscribe();
+	});
+	let currentBytesCount = 0;
+	let currentMessagesCount = 0;
+	function flush(flushReason) {
+		if (currentMessagesCount === 0) return;
+		const messagesCount = currentMessagesCount;
+		const bytesCount = currentBytesCount;
+		currentMessagesCount = 0;
+		currentBytesCount = 0;
+		cancelDurationLimitTimeout();
+		flushObservable.notify({
+			reason: flushReason,
+			messagesCount,
+			bytesCount
+		});
+	}
+	let durationLimitTimeoutId;
+	function scheduleDurationLimitTimeout() {
+		if (durationLimitTimeoutId === void 0) durationLimitTimeoutId = setTimeout(() => {
+			flush("duration_limit");
+		}, FLUSH_DURATION_LIMIT);
+	}
+	function cancelDurationLimitTimeout() {
+		clearTimeout(durationLimitTimeoutId);
+		durationLimitTimeoutId = void 0;
+	}
+	return {
+		flushObservable,
+		preparePageExitFlushObservable,
+		get messagesCount() {
+			return currentMessagesCount;
+		},
+		/**
+		* Notifies that a message will be added to a pool of pending messages waiting to be flushed.
+		*
+		* 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) {
+			if (currentBytesCount + estimatedMessageBytesCount >= RECOMMENDED_REQUEST_BYTES_LIMIT) flush(forcedFlushReason ?? "bytes_limit");
+			currentMessagesCount += 1;
+			currentBytesCount += estimatedMessageBytesCount;
+			scheduleDurationLimitTimeout();
+		},
+		/**
+		* Notifies that a message *was* added to a pool of pending messages waiting to be flushed.
+		*
+		* 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;
+			if (currentMessagesCount >= MESSAGES_LIMIT) flush(forcedFlushReason ?? "messages_limit");
+			else if (currentBytesCount >= RECOMMENDED_REQUEST_BYTES_LIMIT) flush(forcedFlushReason ?? "bytes_limit");
+		}
+	};
+}
+//#endregion
+export { FLUSH_DURATION_LIMIT, createFlushController };
+
+//# sourceMappingURL=flushController.mjs.map

package/esm/transport/flushController.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"flushController.mjs","names":[],"sources":["../../src/transport/flushController.ts"],"sourcesContent":["import { ONE_SECOND } from '@openobserve/js-core/time'\nimport type { Duration } from '@openobserve/js-core/time'\nimport type { PageMayExitEvent, PageExitReason } from '../browser/pageMayExitObservable'\nimport { isWorkerEnvironment } from '../tools/globalObject'\nimport { Observable } from '../tools/observable'\nimport type { TimeoutId } from '../tools/timer'\nimport { clearTimeout, setTimeout } from '../tools/timer'\nimport { RECOMMENDED_REQUEST_BYTES_LIMIT } from './httpRequest'\n\nexport type FlushReason = PageExitReason | 'duration_limit' | 'bytes_limit' | 'messages_limit' | 'session_expire'\n\n/**\n * flush automatically, aim to be lower than ALB connection timeout\n * to maximize connection reuse.\n */\nexport const FLUSH_DURATION_LIMIT = (30 * ONE_SECOND) as Duration\n\n/**\n * When using the SDK in a Worker Environment, we limit the batch size to 1 to ensure it can be sent\n * in a single event.\n */\nexport const MESSAGES_LIMIT = isWorkerEnvironment ? 1 : 50\n\nexport type FlushController = ReturnType<typeof createFlushController>\nexport interface FlushEvent {\n  reason: FlushReason\n  bytesCount: number\n  messagesCount: number\n}\n\ninterface FlushControllerOptions {\n  pageMayExitObservable: Observable<PageMayExitEvent>\n  sessionExpireObservable: Observable<void>\n}\n\n/**\n * Returns a \"flush controller\", responsible of notifying when flushing a pool of pending data needs\n * to happen. The implementation is designed to support both synchronous and asynchronous usages,\n * but relies on invariants described in each method documentation to keep a coherent state.\n */\nexport function createFlushController({ pageMayExitObservable, sessionExpireObservable }: FlushControllerOptions) {\n  let forcedFlushReason: FlushReason | undefined\n  const preparePageExitFlushObservable = new Observable<PageExitReason>()\n  const pageMayExitSubscription = pageMayExitObservable.subscribe((event) => {\n    forcedFlushReason = event.reason\n    try {\n      preparePageExitFlushObservable.notify(event.reason)\n    } finally {\n      forcedFlushReason = undefined\n    }\n    flush(event.reason)\n  })\n  const sessionExpireSubscription = sessionExpireObservable.subscribe(() => flush('session_expire'))\n\n  const flushObservable = new Observable<FlushEvent>(() => () => {\n    pageMayExitSubscription.unsubscribe()\n    sessionExpireSubscription.unsubscribe()\n  })\n\n  let currentBytesCount = 0\n  let currentMessagesCount = 0\n\n  function flush(flushReason: FlushReason) {\n    if (currentMessagesCount === 0) {\n      return\n    }\n\n    const messagesCount = currentMessagesCount\n    const bytesCount = currentBytesCount\n\n    currentMessagesCount = 0\n    currentBytesCount = 0\n    cancelDurationLimitTimeout()\n\n    flushObservable.notify({\n      reason: flushReason,\n      messagesCount,\n      bytesCount,\n    })\n  }\n\n  let durationLimitTimeoutId: TimeoutId | undefined\n  function scheduleDurationLimitTimeout() {\n    if (durationLimitTimeoutId === undefined) {\n      durationLimitTimeoutId = setTimeout(() => {\n        flush('duration_limit')\n      }, FLUSH_DURATION_LIMIT)\n    }\n  }\n\n  function cancelDurationLimitTimeout() {\n    clearTimeout(durationLimitTimeoutId)\n    durationLimitTimeoutId = undefined\n  }\n\n  return {\n    flushObservable,\n    preparePageExitFlushObservable,\n    get messagesCount() {\n      return currentMessagesCount\n    },\n\n    /**\n     * Notifies that a message will be added to a pool of pending messages waiting to be flushed.\n     *\n     * This function needs to be called synchronously, right before adding the message, so no flush\n     * event can happen after `notifyBeforeAddMessage` and before adding the message.\n     *\n     * @param estimatedMessageBytesCount - an estimation of the message bytes count once it is\n     * actually added.\n     */\n    notifyBeforeAddMessage(estimatedMessageBytesCount: number) {\n      if (currentBytesCount + estimatedMessageBytesCount >= RECOMMENDED_REQUEST_BYTES_LIMIT) {\n        flush(forcedFlushReason ?? 'bytes_limit')\n      }\n      // Consider the message to be added now rather than in `notifyAfterAddMessage`, because if no\n      // message was added yet and `notifyAfterAddMessage` is called asynchronously, we still want\n      // to notify when a flush is needed (for example on page exit).\n      currentMessagesCount += 1\n      currentBytesCount += estimatedMessageBytesCount\n      scheduleDurationLimitTimeout()\n    },\n\n    /**\n     * Notifies that a message *was* added to a pool of pending messages waiting to be flushed.\n     *\n     * This function can be called asynchronously after the message was added, but in this case it\n     * should not be called if a flush event occurred in between.\n     *\n     * @param messageBytesCountDiff - the difference between the estimated message bytes count and\n     * its actual bytes count once added to the pool.\n     */\n    notifyAfterAddMessage(messageBytesCountDiff = 0) {\n      currentBytesCount += messageBytesCountDiff\n\n      if (currentMessagesCount >= MESSAGES_LIMIT) {\n        flush(forcedFlushReason ?? 'messages_limit')\n      } else if (currentBytesCount >= RECOMMENDED_REQUEST_BYTES_LIMIT) {\n        flush(forcedFlushReason ?? 'bytes_limit')\n      }\n    },\n  }\n}\n"],"mappings":";;;;;;;;;;AAeA,MAAa,uBAAwB,KAAK;;;;;AAM1C,MAAa,iBAAiB,sBAAsB,IAAI;;;;;;AAmBxD,SAAgB,sBAAsB,EAAE,uBAAuB,2BAAmD;CAChH,IAAI;CACJ,MAAM,iCAAiC,IAAI,WAA2B;CACtE,MAAM,0BAA0B,sBAAsB,WAAW,UAAU;EACzE,oBAAoB,MAAM;EAC1B,IAAI;GACF,+BAA+B,OAAO,MAAM,MAAM;EACpD,UAAU;GACR,oBAAoB,KAAA;EACtB;EACA,MAAM,MAAM,MAAM;CACpB,CAAC;CACD,MAAM,4BAA4B,wBAAwB,gBAAgB,MAAM,gBAAgB,CAAC;CAEjG,MAAM,kBAAkB,IAAI,uBAAmC;EAC7D,wBAAwB,YAAY;EACpC,0BAA0B,YAAY;CACxC,CAAC;CAED,IAAI,oBAAoB;CACxB,IAAI,uBAAuB;CAE3B,SAAS,MAAM,aAA0B;EACvC,IAAI,yBAAyB,GAC3B;EAGF,MAAM,gBAAgB;EACtB,MAAM,aAAa;EAEnB,uBAAuB;EACvB,oBAAoB;EACpB,2BAA2B;EAE3B,gBAAgB,OAAO;GACrB,QAAQ;GACR;GACA;EACF,CAAC;CACH;CAEA,IAAI;CACJ,SAAS,+BAA+B;EACtC,IAAI,2BAA2B,KAAA,GAC7B,yBAAyB,iBAAiB;GACxC,MAAM,gBAAgB;EACxB,GAAG,oBAAoB;CAE3B;CAEA,SAAS,6BAA6B;EACpC,aAAa,sBAAsB;EACnC,yBAAyB,KAAA;CAC3B;CAEA,OAAO;EACL;EACA;EACA,IAAI,gBAAgB;GAClB,OAAO;EACT;;;;;;;;;;EAWA,uBAAuB,4BAAoC;GACzD,IAAI,oBAAoB,8BAA8B,iCACpD,MAAM,qBAAqB,aAAa;GAK1C,wBAAwB;GACxB,qBAAqB;GACrB,6BAA6B;EAC/B;;;;;;;;;;EAWA,sBAAsB,wBAAwB,GAAG;GAC/C,qBAAqB;GAErB,IAAI,wBAAwB,gBAC1B,MAAM,qBAAqB,gBAAgB;QACtC,IAAI,qBAAqB,iCAC9B,MAAM,qBAAqB,aAAa;EAE5C;CACF;AACF"}

package/esm/transport/httpRequest.mjs

@@ -0,0 +1,60 @@
+import { monitor, monitorError } from "../tools/monitor.mjs";
+import { Observable } from "../tools/observable.mjs";
+import { ONE_KIBI_BYTE } from "../tools/utils/byteUtils.mjs";
+import { fetch } from "../browser/fetch.mjs";
+import { newRetryState, sendWithRetryStrategy } from "./sendWithRetryStrategy.mjs";
+//#region src/transport/httpRequest.ts
+/**
+* beacon payload max queue size implementation is 64kb
+* ensure that we leave room for logs, rum and potential other users
+*/
+const RECOMMENDED_REQUEST_BYTES_LIMIT = 16 * ONE_KIBI_BYTE;
+function createHttpRequest(endpointBuilders, reportError, bytesLimit = RECOMMENDED_REQUEST_BYTES_LIMIT) {
+	const observable = new Observable();
+	const retryState = newRetryState();
+	return {
+		observable,
+		send: (payload) => {
+			for (const endpointBuilder of endpointBuilders) sendWithRetryStrategy(payload, retryState, (payload, onResponse) => {
+				fetchStrategy(endpointBuilder, payload, onResponse);
+			}, endpointBuilder.trackType, reportError, observable);
+		},
+		/**
+		* Since fetch keepalive behaves like regular fetch on Firefox,
+		* keep using sendBeaconStrategy on exit
+		*/
+		sendOnExit: (payload) => {
+			for (const endpointBuilder of endpointBuilders) sendBeaconStrategy(endpointBuilder, bytesLimit, payload);
+		}
+	};
+}
+function sendBeaconStrategy(endpointBuilder, bytesLimit, payload) {
+	if (payload.bytesCount < bytesLimit) try {
+		const beaconUrl = endpointBuilder.build("beacon", payload);
+		if (navigator.sendBeacon(beaconUrl, payload.data)) return;
+	} catch (e) {
+		reportBeaconError(e);
+	}
+	fetchStrategy(endpointBuilder, payload);
+}
+let hasReportedBeaconError = false;
+function reportBeaconError(e) {
+	if (!hasReportedBeaconError) {
+		hasReportedBeaconError = true;
+		monitorError(e);
+	}
+}
+function fetchStrategy(endpointBuilder, payload, onResponse) {
+	fetch(endpointBuilder.build("fetch", payload), {
+		method: "POST",
+		body: payload.data,
+		mode: "cors"
+	}).then(monitor((response) => onResponse?.({
+		status: response.status,
+		type: response.type
+	}))).catch(monitor(() => onResponse?.({ status: 0 })));
+}
+//#endregion
+export { RECOMMENDED_REQUEST_BYTES_LIMIT, createHttpRequest };
+
+//# sourceMappingURL=httpRequest.mjs.map

package/esm/transport/httpRequest.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpRequest.mjs","names":[],"sources":["../../src/transport/httpRequest.ts"],"sourcesContent":["import type { EndpointBuilder } from '../domain/configuration'\nimport type { Context } from '../tools/serialisation/context'\nimport { fetch } from '../browser/fetch'\nimport { monitor, monitorError } from '../tools/monitor'\nimport type { RawError } from '../domain/error/error.types'\nimport { Observable } from '../tools/observable'\nimport { ONE_KIBI_BYTE } from '../tools/utils/byteUtils'\nimport { newRetryState, sendWithRetryStrategy } from './sendWithRetryStrategy'\n\n/**\n * beacon payload max queue size implementation is 64kb\n * ensure that we leave room for logs, rum and potential other users\n */\nexport const RECOMMENDED_REQUEST_BYTES_LIMIT = 16 * ONE_KIBI_BYTE\n\n/**\n * Use POST request without content type to:\n * - avoid CORS preflight requests\n * - allow usage of sendBeacon\n *\n * multiple elements are sent separated by \\n in order\n * to be parsed correctly without content type header\n */\n\nexport interface HttpRequest<Body extends Payload = Payload> {\n  observable: Observable<HttpRequestEvent<Body>>\n  send(this: void, payload: Body): void\n  sendOnExit(this: void, payload: Body): void\n}\n\nexport interface HttpResponse extends Context {\n  status: number\n  type?: ResponseType\n}\n\nexport interface BandwidthStats {\n  ongoingByteCount: number\n  ongoingRequestCount: number\n}\n\nexport type HttpRequestEvent<Body extends Payload = Payload> =\n  | {\n      // A request to send the given payload failed. (We may retry.)\n      type: 'failure'\n      bandwidth: BandwidthStats\n      payload: Body\n    }\n  | {\n      // The given payload was discarded because the request queue is full.\n      type: 'queue-full'\n      bandwidth: BandwidthStats\n      payload: Body\n    }\n  | {\n      // A request to send the given payload succeeded.\n      type: 'success'\n      bandwidth: BandwidthStats\n      payload: Body\n    }\n\nexport interface Payload {\n  data: string | FormData | Blob\n  bytesCount: number\n  retry?: RetryInfo\n  encoding?: 'deflate'\n}\n\nexport interface RetryInfo {\n  count: number\n  lastFailureStatus: number\n}\n\nexport function createHttpRequest<Body extends Payload = Payload>(\n  endpointBuilders: EndpointBuilder[],\n  reportError: (error: RawError) => void,\n  bytesLimit: number = RECOMMENDED_REQUEST_BYTES_LIMIT\n): HttpRequest<Body> {\n  const observable = new Observable<HttpRequestEvent<Body>>()\n  const retryState = newRetryState<Body>()\n\n  return {\n    observable,\n    send: (payload: Body) => {\n      for (const endpointBuilder of endpointBuilders) {\n        sendWithRetryStrategy(\n          payload,\n          retryState,\n          (payload, onResponse) => {\n            fetchStrategy(endpointBuilder, payload, onResponse)\n          },\n          endpointBuilder.trackType,\n          reportError,\n          observable\n        )\n      }\n    },\n    /**\n     * Since fetch keepalive behaves like regular fetch on Firefox,\n     * keep using sendBeaconStrategy on exit\n     */\n    sendOnExit: (payload: Body) => {\n      for (const endpointBuilder of endpointBuilders) {\n        sendBeaconStrategy(endpointBuilder, bytesLimit, payload)\n      }\n    },\n  }\n}\n\nfunction sendBeaconStrategy(endpointBuilder: EndpointBuilder, bytesLimit: number, payload: Payload) {\n  const canUseBeacon = payload.bytesCount < bytesLimit\n  if (canUseBeacon) {\n    try {\n      const beaconUrl = endpointBuilder.build('beacon', payload)\n      const isQueued = navigator.sendBeacon(beaconUrl, payload.data)\n\n      if (isQueued) {\n        return\n      }\n    } catch (e) {\n      reportBeaconError(e)\n    }\n  }\n\n  fetchStrategy(endpointBuilder, payload)\n}\n\nlet hasReportedBeaconError = false\n\nfunction reportBeaconError(e: unknown) {\n  if (!hasReportedBeaconError) {\n    hasReportedBeaconError = true\n    monitorError(e)\n  }\n}\n\nexport function fetchStrategy(\n  endpointBuilder: EndpointBuilder,\n  payload: Payload,\n  onResponse?: (r: HttpResponse) => void\n) {\n  const fetchUrl = endpointBuilder.build('fetch', payload)\n\n  fetch(fetchUrl, { method: 'POST', body: payload.data, mode: 'cors' })\n    .then(monitor((response: Response) => onResponse?.({ status: response.status, type: response.type })))\n    .catch(monitor(() => onResponse?.({ status: 0 })))\n}\n"],"mappings":";;;;;;;;;;AAaA,MAAa,kCAAkC,KAAK;AA2DpD,SAAgB,kBACd,kBACA,aACA,aAAqB,iCACF;CACnB,MAAM,aAAa,IAAI,WAAmC;CAC1D,MAAM,aAAa,cAAoB;CAEvC,OAAO;EACL;EACA,OAAO,YAAkB;GACvB,KAAK,MAAM,mBAAmB,kBAC5B,sBACE,SACA,aACC,SAAS,eAAe;IACvB,cAAc,iBAAiB,SAAS,UAAU;GACpD,GACA,gBAAgB,WAChB,aACA,UACF;EAEJ;;;;;EAKA,aAAa,YAAkB;GAC7B,KAAK,MAAM,mBAAmB,kBAC5B,mBAAmB,iBAAiB,YAAY,OAAO;EAE3D;CACF;AACF;AAEA,SAAS,mBAAmB,iBAAkC,YAAoB,SAAkB;CAElG,IADqB,QAAQ,aAAa,YAExC,IAAI;EACF,MAAM,YAAY,gBAAgB,MAAM,UAAU,OAAO;EAGzD,IAFiB,UAAU,WAAW,WAAW,QAAQ,IAE9C,GACT;CAEJ,SAAS,GAAG;EACV,kBAAkB,CAAC;CACrB;CAGF,cAAc,iBAAiB,OAAO;AACxC;AAEA,IAAI,yBAAyB;AAE7B,SAAS,kBAAkB,GAAY;CACrC,IAAI,CAAC,wBAAwB;EAC3B,yBAAyB;EACzB,aAAa,CAAC;CAChB;AACF;AAEA,SAAgB,cACd,iBACA,SACA,YACA;CAGA,MAFiB,gBAAgB,MAAM,SAAS,OAEnC,GAAG;EAAE,QAAQ;EAAQ,MAAM,QAAQ;EAAM,MAAM;CAAO,CAAC,CAAC,CAClE,KAAK,SAAS,aAAuB,aAAa;EAAE,QAAQ,SAAS;EAAQ,MAAM,SAAS;CAAK,CAAC,CAAC,CAAC,CAAC,CACrG,MAAM,cAAc,aAAa,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC;AACrD"}

package/esm/transport/sendWithRetryStrategy.mjs

@@ -0,0 +1,149 @@
+import { setTimeout } from "../tools/timer.mjs";
+import { ONE_KIBI_BYTE, ONE_MEBI_BYTE } from "../tools/utils/byteUtils.mjs";
+import { ErrorSource } from "../domain/error/error.types.mjs";
+import { isServerError } from "../tools/utils/responseUtils.mjs";
+import { ONE_MINUTE, ONE_SECOND, clocksNow } from "@openobserve/js-core/time";
+//#region src/transport/sendWithRetryStrategy.ts
+const MAX_ONGOING_BYTES_COUNT = 80 * ONE_KIBI_BYTE;
+const MAX_QUEUE_BYTES_COUNT = 20 * ONE_MEBI_BYTE;
+const MAX_BACKOFF_TIME = ONE_MINUTE;
+const INITIAL_BACKOFF_TIME = ONE_SECOND;
+function sendWithRetryStrategy(payload, state, sendStrategy, trackType, reportError, requestObservable) {
+	if (state.transportStatus === 0 && state.queuedPayloads.size() === 0 && state.bandwidthMonitor.canHandle(payload)) send(payload, state, sendStrategy, requestObservable, {
+		onSuccess: () => retryQueuedPayloads(0, state, sendStrategy, trackType, reportError, requestObservable),
+		onFailure: () => {
+			if (!state.queuedPayloads.enqueue(payload)) requestObservable.notify({
+				type: "queue-full",
+				bandwidth: state.bandwidthMonitor.stats(),
+				payload
+			});
+			scheduleRetry(state, sendStrategy, trackType, reportError, requestObservable);
+		}
+	});
+	else if (!state.queuedPayloads.enqueue(payload)) requestObservable.notify({
+		type: "queue-full",
+		bandwidth: state.bandwidthMonitor.stats(),
+		payload
+	});
+}
+function scheduleRetry(state, sendStrategy, trackType, reportError, requestObservable) {
+	if (state.transportStatus !== 2) return;
+	setTimeout(() => {
+		send(state.queuedPayloads.first(), state, sendStrategy, requestObservable, {
+			onSuccess: () => {
+				state.queuedPayloads.dequeue();
+				state.currentBackoffTime = INITIAL_BACKOFF_TIME;
+				retryQueuedPayloads(1, state, sendStrategy, trackType, reportError, requestObservable);
+			},
+			onFailure: () => {
+				state.currentBackoffTime = Math.min(MAX_BACKOFF_TIME, state.currentBackoffTime * 2);
+				scheduleRetry(state, sendStrategy, trackType, reportError, requestObservable);
+			}
+		});
+	}, state.currentBackoffTime);
+}
+function send(payload, state, sendStrategy, requestObservable, { onSuccess, onFailure }) {
+	state.bandwidthMonitor.add(payload);
+	sendStrategy(payload, (response) => {
+		state.bandwidthMonitor.remove(payload);
+		if (!shouldRetryRequest(response)) {
+			state.transportStatus = 0;
+			requestObservable.notify({
+				type: "success",
+				bandwidth: state.bandwidthMonitor.stats(),
+				payload
+			});
+			onSuccess();
+		} else {
+			state.transportStatus = state.bandwidthMonitor.ongoingRequestCount > 0 ? 1 : 2;
+			payload.retry = {
+				count: payload.retry ? payload.retry.count + 1 : 1,
+				lastFailureStatus: response.status
+			};
+			requestObservable.notify({
+				type: "failure",
+				bandwidth: state.bandwidthMonitor.stats(),
+				payload
+			});
+			onFailure();
+		}
+	});
+}
+function retryQueuedPayloads(reason, state, sendStrategy, trackType, reportError, requestObservable) {
+	if (reason === 0 && state.queuedPayloads.isFull() && !state.queueFullReported) {
+		reportError({
+			message: `Reached max ${trackType} events size queued for upload: ${MAX_QUEUE_BYTES_COUNT / ONE_MEBI_BYTE}MiB`,
+			source: ErrorSource.AGENT,
+			startClocks: clocksNow()
+		});
+		state.queueFullReported = true;
+	}
+	const previousQueue = state.queuedPayloads;
+	state.queuedPayloads = newPayloadQueue();
+	while (previousQueue.size() > 0) sendWithRetryStrategy(previousQueue.dequeue(), state, sendStrategy, trackType, reportError, requestObservable);
+}
+function shouldRetryRequest(response) {
+	return response.type !== "opaque" && (response.status === 0 && !navigator.onLine || response.status === 408 || response.status === 429 || isServerError(response.status));
+}
+function newRetryState() {
+	return {
+		transportStatus: 0,
+		currentBackoffTime: INITIAL_BACKOFF_TIME,
+		bandwidthMonitor: newBandwidthMonitor(),
+		queuedPayloads: newPayloadQueue(),
+		queueFullReported: false
+	};
+}
+function newPayloadQueue() {
+	const queue = [];
+	return {
+		bytesCount: 0,
+		enqueue(payload) {
+			if (this.isFull()) return false;
+			queue.push(payload);
+			this.bytesCount += payload.bytesCount;
+			return true;
+		},
+		first() {
+			return queue[0];
+		},
+		dequeue() {
+			const payload = queue.shift();
+			if (payload) this.bytesCount -= payload.bytesCount;
+			return payload;
+		},
+		size() {
+			return queue.length;
+		},
+		isFull() {
+			return this.bytesCount >= MAX_QUEUE_BYTES_COUNT;
+		}
+	};
+}
+function newBandwidthMonitor() {
+	return {
+		ongoingRequestCount: 0,
+		ongoingByteCount: 0,
+		canHandle(payload) {
+			return this.ongoingRequestCount === 0 || this.ongoingByteCount + payload.bytesCount <= MAX_ONGOING_BYTES_COUNT && this.ongoingRequestCount < 32;
+		},
+		add(payload) {
+			this.ongoingRequestCount += 1;
+			this.ongoingByteCount += payload.bytesCount;
+		},
+		remove(payload) {
+			this.ongoingRequestCount -= 1;
+			this.ongoingByteCount -= payload.bytesCount;
+		},
+		stats() {
+			return {
+				ongoingByteCount: this.ongoingByteCount,
+				ongoingRequestCount: this.ongoingRequestCount
+			};
+		}
+	};
+}
+//#endregion
+export { newRetryState, sendWithRetryStrategy };
+
+//# sourceMappingURL=sendWithRetryStrategy.mjs.map

package/esm/transport/sendWithRetryStrategy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sendWithRetryStrategy.mjs","names":[],"sources":["../../src/transport/sendWithRetryStrategy.ts"],"sourcesContent":["import { ONE_MINUTE, ONE_SECOND, clocksNow } from '@openobserve/js-core/time'\nimport type { TrackType } from '../domain/configuration'\nimport { setTimeout } from '../tools/timer'\nimport { ONE_MEBI_BYTE, ONE_KIBI_BYTE } from '../tools/utils/byteUtils'\nimport { isServerError } from '../tools/utils/responseUtils'\nimport type { RawError } from '../domain/error/error.types'\nimport { ErrorSource } from '../domain/error/error.types'\nimport type { Observable } from '../tools/observable'\nimport type { Payload, HttpRequestEvent, HttpResponse, BandwidthStats } from './httpRequest'\n\nexport const MAX_ONGOING_BYTES_COUNT = 80 * ONE_KIBI_BYTE\nexport const MAX_ONGOING_REQUESTS = 32\nexport const MAX_QUEUE_BYTES_COUNT = 20 * ONE_MEBI_BYTE\nexport const MAX_BACKOFF_TIME = ONE_MINUTE\nexport const INITIAL_BACKOFF_TIME = ONE_SECOND\n\nconst enum TransportStatus {\n  UP,\n  FAILURE_DETECTED,\n  DOWN,\n}\n\nconst enum RetryReason {\n  AFTER_SUCCESS,\n  AFTER_RESUME,\n}\n\nexport interface RetryState<Body extends Payload> {\n  transportStatus: TransportStatus\n  currentBackoffTime: number\n  bandwidthMonitor: ReturnType<typeof newBandwidthMonitor>\n  queuedPayloads: ReturnType<typeof newPayloadQueue<Body>>\n  queueFullReported: boolean\n}\n\ntype SendStrategy<Body extends Payload> = (payload: Body, onResponse: (r: HttpResponse) => void) => void\n\nexport function sendWithRetryStrategy<Body extends Payload>(\n  payload: Body,\n  state: RetryState<Body>,\n  sendStrategy: SendStrategy<Body>,\n  trackType: TrackType,\n  reportError: (error: RawError) => void,\n  requestObservable: Observable<HttpRequestEvent<Body>>\n) {\n  if (\n    state.transportStatus === TransportStatus.UP &&\n    state.queuedPayloads.size() === 0 &&\n    state.bandwidthMonitor.canHandle(payload)\n  ) {\n    send(payload, state, sendStrategy, requestObservable, {\n      onSuccess: () =>\n        retryQueuedPayloads(RetryReason.AFTER_SUCCESS, state, sendStrategy, trackType, reportError, requestObservable),\n      onFailure: () => {\n        if (!state.queuedPayloads.enqueue(payload)) {\n          requestObservable.notify({ type: 'queue-full', bandwidth: state.bandwidthMonitor.stats(), payload })\n        }\n        scheduleRetry(state, sendStrategy, trackType, reportError, requestObservable)\n      },\n    })\n  } else {\n    if (!state.queuedPayloads.enqueue(payload)) {\n      requestObservable.notify({ type: 'queue-full', bandwidth: state.bandwidthMonitor.stats(), payload })\n    }\n  }\n}\n\nfunction scheduleRetry<Body extends Payload>(\n  state: RetryState<Body>,\n  sendStrategy: SendStrategy<Body>,\n  trackType: TrackType,\n  reportError: (error: RawError) => void,\n  requestObservable: Observable<HttpRequestEvent<Body>>\n) {\n  if (state.transportStatus !== TransportStatus.DOWN) {\n    return\n  }\n  setTimeout(() => {\n    const payload = state.queuedPayloads.first()\n    send(payload, state, sendStrategy, requestObservable, {\n      onSuccess: () => {\n        state.queuedPayloads.dequeue()\n        state.currentBackoffTime = INITIAL_BACKOFF_TIME\n        retryQueuedPayloads(RetryReason.AFTER_RESUME, state, sendStrategy, trackType, reportError, requestObservable)\n      },\n      onFailure: () => {\n        state.currentBackoffTime = Math.min(MAX_BACKOFF_TIME, state.currentBackoffTime * 2)\n        scheduleRetry(state, sendStrategy, trackType, reportError, requestObservable)\n      },\n    })\n  }, state.currentBackoffTime)\n}\n\nfunction send<Body extends Payload>(\n  payload: Body,\n  state: RetryState<Body>,\n  sendStrategy: SendStrategy<Body>,\n  requestObservable: Observable<HttpRequestEvent<Body>>,\n  { onSuccess, onFailure }: { onSuccess: () => void; onFailure: () => void }\n) {\n  state.bandwidthMonitor.add(payload)\n  sendStrategy(payload, (response) => {\n    state.bandwidthMonitor.remove(payload)\n    if (!shouldRetryRequest(response)) {\n      state.transportStatus = TransportStatus.UP\n      requestObservable.notify({ type: 'success', bandwidth: state.bandwidthMonitor.stats(), payload })\n      onSuccess()\n    } else {\n      // do not consider transport down if another ongoing request could succeed\n      state.transportStatus =\n        state.bandwidthMonitor.ongoingRequestCount > 0 ? TransportStatus.FAILURE_DETECTED : TransportStatus.DOWN\n      payload.retry = {\n        count: payload.retry ? payload.retry.count + 1 : 1,\n        lastFailureStatus: response.status,\n      }\n      requestObservable.notify({ type: 'failure', bandwidth: state.bandwidthMonitor.stats(), payload })\n      onFailure()\n    }\n  })\n}\n\nfunction retryQueuedPayloads<Body extends Payload>(\n  reason: RetryReason,\n  state: RetryState<Body>,\n  sendStrategy: SendStrategy<Body>,\n  trackType: TrackType,\n  reportError: (error: RawError) => void,\n  requestObservable: Observable<HttpRequestEvent<Body>>\n) {\n  if (reason === RetryReason.AFTER_SUCCESS && state.queuedPayloads.isFull() && !state.queueFullReported) {\n    reportError({\n      message: `Reached max ${trackType} events size queued for upload: ${MAX_QUEUE_BYTES_COUNT / ONE_MEBI_BYTE}MiB`,\n      source: ErrorSource.AGENT,\n      startClocks: clocksNow(),\n    })\n    state.queueFullReported = true\n  }\n  const previousQueue = state.queuedPayloads\n  state.queuedPayloads = newPayloadQueue()\n  while (previousQueue.size() > 0) {\n    sendWithRetryStrategy(previousQueue.dequeue()!, state, sendStrategy, trackType, reportError, requestObservable)\n  }\n}\n\nfunction shouldRetryRequest(response: HttpResponse) {\n  return (\n    response.type !== 'opaque' &&\n    ((response.status === 0 && !navigator.onLine) ||\n      response.status === 408 ||\n      response.status === 429 ||\n      isServerError(response.status))\n  )\n}\n\nexport function newRetryState<Body extends Payload>(): RetryState<Body> {\n  return {\n    transportStatus: TransportStatus.UP,\n    currentBackoffTime: INITIAL_BACKOFF_TIME,\n    bandwidthMonitor: newBandwidthMonitor(),\n    queuedPayloads: newPayloadQueue(),\n    queueFullReported: false,\n  }\n}\n\nfunction newPayloadQueue<Body extends Payload>() {\n  const queue: Body[] = []\n  return {\n    bytesCount: 0,\n    enqueue(payload: Body) {\n      if (this.isFull()) {\n        return false\n      }\n      queue.push(payload)\n      this.bytesCount += payload.bytesCount\n      return true\n    },\n    first() {\n      return queue[0]\n    },\n    dequeue() {\n      const payload = queue.shift()\n      if (payload) {\n        this.bytesCount -= payload.bytesCount\n      }\n      return payload\n    },\n    size() {\n      return queue.length\n    },\n    isFull() {\n      return this.bytesCount >= MAX_QUEUE_BYTES_COUNT\n    },\n  }\n}\n\nfunction newBandwidthMonitor() {\n  return {\n    ongoingRequestCount: 0,\n    ongoingByteCount: 0,\n    canHandle(payload: Payload) {\n      return (\n        this.ongoingRequestCount === 0 ||\n        (this.ongoingByteCount + payload.bytesCount <= MAX_ONGOING_BYTES_COUNT &&\n          this.ongoingRequestCount < MAX_ONGOING_REQUESTS)\n      )\n    },\n    add(payload: Payload) {\n      this.ongoingRequestCount += 1\n      this.ongoingByteCount += payload.bytesCount\n    },\n    remove(payload: Payload) {\n      this.ongoingRequestCount -= 1\n      this.ongoingByteCount -= payload.bytesCount\n    },\n    stats(): BandwidthStats {\n      return {\n        ongoingByteCount: this.ongoingByteCount,\n        ongoingRequestCount: this.ongoingRequestCount,\n      }\n    },\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -1,18 +1,29 @@
 {
   "name": "@openobserve/browser-core",
-  "version": "0.3.4",
+  "version": "0.4.0-beta.1",
   "license": "Apache-2.0",
   "main": "cjs/index.js",
-  "module": "esm/index.js",
+  "module": "esm/index.mjs",
   "types": "cjs/index.d.ts",
   "sideEffects": false,
+  "files": [
+    "cjs",
+    "esm",
+    "src",
+    "!src/**/*.spec.ts",
+    "!src/**/*.specHelper.ts"
+  ],
   "scripts": {
-    "build": "node ../../scripts/build/build-package.ts --modules"
+    "build": "node ../../scripts/build/build-package.ts --modules",
+    "prepack": "yarn build"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/openobserve/browser-sdk.git",
-    "directory": "packages/core"
+    "directory": "packages/browser-core"
+  },
+  "dependencies": {
+    "@openobserve/js-core": "0.4.0-beta.1"
   },
   "devDependencies": {
     "@types/pako": "2.0.4",

package/src/boot/init.ts

@@ -1,5 +1,5 @@
+import { setDebugMode } from '@openobserve/js-core/util'
 import { catchUserErrors } from '../tools/catchUserErrors'
-import { setDebugMode } from '../tools/monitor'
 import { display } from '../tools/display'
 
 // replaced at build time
@@ -49,7 +49,7 @@ export function defineGlobal<Global, Name extends keyof Global>(global: Global,
     display.warn('SDK is loaded more than once. This is unsupported and might have unexpected behavior.')
   }
   global[name] = api
-  if (existingGlobalVariable && existingGlobalVariable.q) {
+  if (existingGlobalVariable?.q) {
     existingGlobalVariable.q.forEach((fn) => catchUserErrors(fn, 'onReady callback threw an error:')())
   }
 }

package/src/browser/addEventListener.ts

@@ -1,5 +1,6 @@
 import { monitor } from '../tools/monitor'
 import { getZoneJsOriginalValue } from '../tools/getZoneJsOriginalValue'
+import { noop } from '../tools/utils/functionUtils'
 import type { CookieStore, CookieStoreEventMap, VisualViewport, VisualViewportEventMap } from './browser.types'
 
 export type TrustableEvent<E extends Event = Event> = E & { __ooIsTrusted?: boolean }
@@ -39,6 +40,7 @@ export const enum DOM_EVENT {
   SECURITY_POLICY_VIOLATION = 'securitypolicyviolation',
   SELECTION_CHANGE = 'selectionchange',
   STORAGE = 'storage',
+  UNHANDLED_REJECTION = 'unhandledrejection',
 }
 
 interface AddEventListenerOptions {
@@ -56,7 +58,10 @@ type EventMapFor<T> = T extends Window
       visibilitychange: Event
     }
   : T extends Document
-    ? DocumentEventMap
+    ? DocumentEventMap & {
+        // TS 4.9.5 does not define `prerenderingchange` on Document yet (Speculation Rules / Prerender2)
+        prerenderingchange: Event
+      }
     : T extends HTMLElement
       ? HTMLElementEventMap
       : T extends VisualViewport
@@ -87,13 +92,12 @@ type EventMapFor<T> = T extends Window
  * * returns a `stop` function to remove the listener
  */
 export function addEventListener<Target extends EventTarget, EventName extends keyof EventMapFor<Target> & string>(
-  configuration: { allowUntrustedEvents?: boolean | undefined },
   eventTarget: Target,
   eventName: EventName,
   listener: (event: EventMapFor<Target>[EventName] & { type: EventName }) => void,
   options?: AddEventListenerOptions
 ) {
-  return addEventListeners(configuration, eventTarget, [eventName], listener, options)
+  return addEventListeners(eventTarget, [eventName], listener, options)
 }
 
 /**
@@ -109,14 +113,13 @@ export function addEventListener<Target extends EventTarget, EventName extends k
  * * with `once: true`, the listener will be called at most once, even if different events are listened
  */
 export function addEventListeners<Target extends EventTarget, EventName extends keyof EventMapFor<Target> & string>(
-  configuration: { allowUntrustedEvents?: boolean | undefined },
   eventTarget: Target,
   eventNames: EventName[],
   listener: (event: EventMapFor<Target>[EventName] & { type: EventName }) => void,
   { once, capture, passive }: AddEventListenerOptions = {}
 ) {
   const listenerWithMonitor = monitor((event: TrustableEvent) => {
-    if (!event.isTrusted && !event.__ooIsTrusted && !configuration.allowUntrustedEvents) {
+    if (!event.isTrusted && !event.__ooIsTrusted && allowUntrustedEventsFromConfiguration === false) {
       return
     }
     if (once) {
@@ -143,3 +146,32 @@ export function addEventListeners<Target extends EventTarget, EventName extends
     stop,
   }
 }
+
+export function isEventSupported<Target extends EventTarget, EventName extends keyof EventMapFor<Target> & string>(
+  eventTarget: Target | undefined,
+  eventName: EventName
+) {
+  if (!eventTarget) {
+    return false
+  }
+
+  try {
+    addEventListener(eventTarget, eventName, noop).stop()
+    return true
+  } catch {
+    return false
+  }
+}
+
+let allowUntrustedEventsFromConfiguration: boolean | undefined
+
+export function setAllowUntrustedEvents(value: boolean | undefined) {
+  if (allowUntrustedEventsFromConfiguration === true) {
+    return // keep the laxer value (true)
+  }
+  allowUntrustedEventsFromConfiguration = value ?? false
+}
+
+export function resetAllowUntrustedEvents() {
+  allowUntrustedEventsFromConfiguration = undefined
+}

package/src/browser/browser.types.ts

@@ -51,20 +51,31 @@ export interface WeakRefConstructor {
   new <T extends object>(target: T): WeakRef<T>
 }
 
+export interface CookieStoreItem {
+  name: string
+  value: string
+  domain?: string
+  path?: string
+  expires?: number
+  secure?: boolean
+  sameSite?: 'strict' | 'lax' | 'none'
+  partitioned?: boolean
+}
+
 export interface CookieStore extends EventTarget {
-  get(name: string): Promise<unknown>
-  getAll(name?: string): Promise<
-    Array<{
-      name: string
-      value: string
-      domain?: string
-      path?: string
-      expires?: number
-      secure?: boolean
-      sameSite?: 'strict' | 'lax' | 'none'
-      partitioned?: boolean
-    }>
-  >
+  get(name: string): Promise<CookieStoreItem | null>
+  getAll(name?: string): Promise<CookieStoreItem[]>
+  set(options: {
+    name: string
+    value: string
+    expires?: number | Date
+    domain?: string
+    path?: string
+    secure?: boolean
+    sameSite?: 'strict' | 'lax' | 'none'
+    partitioned?: boolean
+  }): Promise<void>
+  delete(options: { name: string; domain?: string; path?: string; partitioned?: boolean }): Promise<void>
 }
 
 export interface CookieStoreEventMap {
@@ -80,3 +91,106 @@ export type CookieChangeEvent = Event & {
   changed: CookieChangeItem[]
   deleted: CookieChangeItem[]
 }
+
+export type NetworkInterface = 'bluetooth' | 'cellular' | 'ethernet' | 'none' | 'wifi' | 'wimax' | 'other' | 'unknown'
+export type EffectiveType = 'slow-2g' | '2g' | '3g' | '4g'
+
+export interface BrowserNavigator extends Navigator {
+  connection?: NetworkInformation
+}
+
+export interface NetworkInformation {
+  type?: NetworkInterface
+  effectiveType?: EffectiveType
+  saveData: boolean
+}
+
+// Types for the JS Self-Profiling API
+// https://wicg.github.io/js-self-profiling/
+
+export interface ProfilerFrame {
+  /** A function instance name. */
+  readonly name: string
+  /** Index in the trace.resources array. */
+  readonly resourceId?: number
+  /** 1-based index of the line. */
+  readonly line?: number
+  /** 1-based index of the column. */
+  readonly column?: number
+}
+
+export interface ProfilerStack {
+  /** Index in the trace.stacks array. */
+  readonly parentId?: number
+  /** Index in the trace.frames array. */
+  readonly frameId: number
+}
+
+export interface ProfilerSample {
+  /** High resolution time relative to the profiling session's time origin. */
+  readonly timestamp: number
+  /** Index in the trace.stacks array. */
+  readonly stackId?: number
+}
+
+export type ProfilerResource = string
+
+export interface ProfilerTrace {
+  /** An array of profiler resources. */
+  readonly resources: ProfilerResource[]
+  /** An array of profiler frames. */
+  readonly frames: ProfilerFrame[]
+  /** An array of profiler stacks. */
+  readonly stacks: ProfilerStack[]
+  /** An array of profiler samples. */
+  readonly samples: ProfilerSample[]
+}
+
+export interface ProfilerInitOptions {
+  /** Sample interval in ms. */
+  readonly sampleInterval: number
+  /** Max buffer size in number of samples. */
+  readonly maxBufferSize: number
+}
+
+export interface ProfilerConstructor {
+  new (options: ProfilerInitOptions): Profiler
+}
+
+export interface Profiler extends EventTarget {
+  /** Sample interval in ms. */
+  readonly sampleInterval: number
+  /** True if profiler is stopped. */
+  readonly stopped: boolean
+
+  stop(): Promise<ProfilerTrace>
+
+  addEventListener<K extends keyof ProfilerEventMap>(
+    type: K,
+    listener: (ev: ProfilerEventMap[K]) => any,
+    options?: boolean | AddEventListenerOptions
+  ): void
+  addEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | AddEventListenerOptions
+  ): void
+  removeEventListener<K extends keyof ProfilerEventMap>(
+    type: K,
+    listener: (ev: ProfilerEventMap[K]) => any,
+    options?: boolean | EventListenerOptions
+  ): void
+  removeEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | EventListenerOptions
+  ): void
+}
+
+interface ProfilerEventMap {
+  samplebufferfull: SampleBufferFullEvent
+}
+
+export interface SampleBufferFullEvent extends Event {
+  readonly target: Profiler
+}