@kubesense/kubesense-browser-core 1.7.0 → 2.0.0-beta.0

package/cjs/transport/flushController.js

@@ -1,123 +1,104 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MESSAGES_LIMIT = exports.FLUSH_DURATION_LIMIT = void 0;
-exports.createFlushController = createFlushController;
-const globalObject_1 = require("../tools/globalObject");
-const observable_1 = require("../tools/observable");
-const timer_1 = require("../tools/timer");
-const timeUtils_1 = require("../tools/utils/timeUtils");
-const httpRequest_1 = require("./httpRequest");
+const require_observable = require("../tools/observable.js");
+const require_timer = require("../tools/timer.js");
+const require_httpRequest = require("./httpRequest.js");
+let _kubesense_kubesense_js_core_util = require("@kubesense/kubesense-js-core/util");
+//#region src/transport/flushController.ts
 /**
- * flush automatically, aim to be lower than ALB connection timeout
- * to maximize connection reuse.
- */
-exports.FLUSH_DURATION_LIMIT = (30 * timeUtils_1.ONE_SECOND);
+* flush automatically, aim to be lower than ALB connection timeout
+* to maximize connection reuse.
+*/
+const FLUSH_DURATION_LIMIT = 30 * require("@kubesense/kubesense-js-core/time").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.
- */
-exports.MESSAGES_LIMIT = globalObject_1.isWorkerEnvironment ? 1 : 50;
+* 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 = _kubesense_kubesense_js_core_util.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 }) {
-    const pageMayExitSubscription = pageMayExitObservable.subscribe((event) => flush(event.reason));
-    const sessionExpireSubscription = sessionExpireObservable.subscribe(() => flush('session_expire'));
-    const flushObservable = new observable_1.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 === undefined) {
-            durationLimitTimeoutId = (0, timer_1.setTimeout)(() => {
-                flush('duration_limit');
-            }, exports.FLUSH_DURATION_LIMIT);
-        }
-    }
-    function cancelDurationLimitTimeout() {
-        (0, timer_1.clearTimeout)(durationLimitTimeoutId);
-        durationLimitTimeoutId = undefined;
-    }
-    return {
-        flushObservable,
-        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 >= httpRequest_1.RECOMMENDED_REQUEST_BYTES_LIMIT) {
-                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;
-            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 >= exports.MESSAGES_LIMIT) {
-                flush('messages_limit');
-            }
-            else if (currentBytesCount >= httpRequest_1.RECOMMENDED_REQUEST_BYTES_LIMIT) {
-                flush('bytes_limit');
-            }
-        },
-        /**
-         * Notifies that a message was removed from a pool of pending messages waiting to be flushed.
-         *
-         * 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) {
-            currentBytesCount -= messageBytesCount;
-            currentMessagesCount -= 1;
-            if (currentMessagesCount === 0) {
-                cancelDurationLimitTimeout();
-            }
-        },
-    };
+* 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 }) {
+	let forcedFlushReason;
+	const prepareUrgentFlushObservable = new require_observable.Observable();
+	const pageMayExitSubscription = pageMayExitObservable.subscribe((event) => {
+		forcedFlushReason = event.reason;
+		try {
+			prepareUrgentFlushObservable.notify(event.reason);
+		} finally {
+			forcedFlushReason = void 0;
+		}
+		flush(event.reason);
+	});
+	const flushObservable = new require_observable.Observable(() => () => {
+		pageMayExitSubscription.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 = require_timer.setTimeout(() => {
+			flush("duration_limit");
+		}, FLUSH_DURATION_LIMIT);
+	}
+	function cancelDurationLimitTimeout() {
+		require_timer.clearTimeout(durationLimitTimeoutId);
+		durationLimitTimeoutId = void 0;
+	}
+	return {
+		flushObservable,
+		prepareUrgentFlushObservable,
+		forceFlush: flush,
+		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 >= require_httpRequest.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 >= require_httpRequest.RECOMMENDED_REQUEST_BYTES_LIMIT) flush(forcedFlushReason ?? "bytes_limit");
+		}
+	};
 }
+//#endregion
+exports.FLUSH_DURATION_LIMIT = FLUSH_DURATION_LIMIT;
+exports.MESSAGES_LIMIT = MESSAGES_LIMIT;
+exports.createFlushController = createFlushController;
+
 //# sourceMappingURL=flushController.js.map

package/cjs/transport/flushController.js.map

@@ -1 +1 @@
-{"version":3,"file":"flushController.js","sourceRoot":"","sources":["../../src/transport/flushController.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"flushController.js","names":["ONE_SECOND","isWorkerEnvironment","Observable","setTimeout","RECOMMENDED_REQUEST_BYTES_LIMIT"],"sources":["../../src/transport/flushController.ts"],"sourcesContent":["import { ONE_SECOND } from '@kubesense/kubesense-js-core/time'\nimport type { Duration } from '@kubesense/kubesense-js-core/time'\nimport { isWorkerEnvironment } from '@kubesense/kubesense-js-core/util'\nimport type { PageMayExitEvent, PageExitReason } from '../browser/pageMayExitObservable'\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 UrgentFlushReason = PageExitReason\nexport type FlushReason = UrgentFlushReason | '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}\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 }: FlushControllerOptions) {\n  let forcedFlushReason: FlushReason | undefined\n  const prepareUrgentFlushObservable = new Observable<UrgentFlushReason>()\n  const pageMayExitSubscription = pageMayExitObservable.subscribe((event) => {\n    forcedFlushReason = event.reason\n    try {\n      prepareUrgentFlushObservable.notify(event.reason)\n    } finally {\n      forcedFlushReason = undefined\n    }\n    flush(event.reason)\n  })\n\n  const flushObservable = new Observable<FlushEvent>(() => () => {\n    pageMayExitSubscription.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    prepareUrgentFlushObservable,\n    forceFlush: flush,\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":";;;;;;;;;AAgBA,MAAa,uBAAwB,gDAAKA,CAAAA,CAAAA;;;;;AAM1C,MAAa,iBAAiBC,kCAAAA,sBAAsB,IAAI;;;;;;AAkBxD,SAAgB,sBAAsB,EAAE,yBAAiD;CACvF,IAAI;CACJ,MAAM,+BAA+B,IAAIC,mBAAAA,WAA8B;CACvE,MAAM,0BAA0B,sBAAsB,WAAW,UAAU;EACzE,oBAAoB,MAAM;EAC1B,IAAI;GACF,6BAA6B,OAAO,MAAM,MAAM;EAClD,UAAU;GACR,oBAAoB,KAAA;EACtB;EACA,MAAM,MAAM,MAAM;CACpB,CAAC;CAED,MAAM,kBAAkB,IAAIA,mBAAAA,uBAAmC;EAC7D,wBAAwB,YAAY;CACtC,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,yBAAyBC,cAAAA,iBAAiB;GACxC,MAAM,gBAAgB;EACxB,GAAG,oBAAoB;CAE3B;CAEA,SAAS,6BAA6B;EACpC,cAAA,aAAa,sBAAsB;EACnC,yBAAyB,KAAA;CAC3B;CAEA,OAAO;EACL;EACA;EACA,YAAY;EACZ,IAAI,gBAAgB;GAClB,OAAO;EACT;;;;;;;;;;EAWA,uBAAuB,4BAAoC;GACzD,IAAI,oBAAoB,8BAA8BC,oBAAAA,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,qBAAqBA,oBAAAA,iCAC9B,MAAM,qBAAqB,aAAa;EAE5C;CACF;AACF"}

package/cjs/transport/httpRequest.d.ts

@@ -1,6 +1,5 @@
-import type { EndpointBuilder } from '../domain/configuration';
+import type { EndpointBuilder, TransportRetryInfo } from '@kubesense/kubesense-js-core/transport';
 import type { Context } from '../tools/serialisation/context';
-import type { RawError } from '../domain/error/error.types';
 import { Observable } from '../tools/observable';
 /**
  * beacon payload max queue size implementation is 64kb
@@ -41,17 +40,17 @@ export type HttpRequestEvent<Body extends Payload = Payload> = {
     type: 'success';
     bandwidth: BandwidthStats;
     payload: Body;
+} | {
+    type: 'dropped';
+    bandwidth: BandwidthStats;
+    payload: Body;
+    status: number;
 };
 export interface Payload {
     data: string | FormData | Blob;
     bytesCount: number;
-    retry?: RetryInfo;
+    retry?: TransportRetryInfo;
     encoding?: 'deflate';
 }
-export interface RetryInfo {
-    count: number;
-    lastFailureStatus: number;
-}
-export declare function createHttpRequest<Body extends Payload = Payload>(endpointBuilders: EndpointBuilder[], reportError: (error: RawError) => void, bytesLimit?: number): HttpRequest<Body>;
-export declare function fetchKeepAliveStrategy(endpointBuilder: EndpointBuilder, bytesLimit: number, payload: Payload, onResponse?: (r: HttpResponse) => void): void;
+export declare function createHttpRequest<Body extends Payload = Payload>(endpointBuilders: EndpointBuilder[], reportError: (message: string) => void, bytesLimit?: number, networkErrorRetries?: number): HttpRequest<Body>;
 export declare function fetchStrategy(endpointBuilder: EndpointBuilder, payload: Payload, onResponse?: (r: HttpResponse) => void): void;

package/cjs/transport/httpRequest.js

@@ -1,107 +1,71 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RECOMMENDED_REQUEST_BYTES_LIMIT = void 0;
-exports.createHttpRequest = createHttpRequest;
-exports.fetchKeepAliveStrategy = fetchKeepAliveStrategy;
-exports.fetchStrategy = fetchStrategy;
-const monitor_1 = require("../tools/monitor");
-const experimentalFeatures_1 = require("../tools/experimentalFeatures");
-const observable_1 = require("../tools/observable");
-const byteUtils_1 = require("../tools/utils/byteUtils");
-const sendWithRetryStrategy_1 = require("./sendWithRetryStrategy");
+const require_observable = require("../tools/observable.js");
+const require_fetch = require("../browser/fetch.js");
+const require_byteUtils = require("../tools/utils/byteUtils.js");
+const require_sendWithRetryStrategy = require("./sendWithRetryStrategy.js");
+let _kubesense_kubesense_js_core_monitor = require("@kubesense/kubesense-js-core/monitor");
+//#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
- */
-exports.RECOMMENDED_REQUEST_BYTES_LIMIT = 16 * byteUtils_1.ONE_KIBI_BYTE;
-function createHttpRequest(endpointBuilders, reportError, bytesLimit = exports.RECOMMENDED_REQUEST_BYTES_LIMIT) {
-    const observable = new observable_1.Observable();
-    const retryState = (0, sendWithRetryStrategy_1.newRetryState)();
-    return {
-        observable,
-        send: (payload) => {
-            for (const endpointBuilder of endpointBuilders) {
-                (0, sendWithRetryStrategy_1.sendWithRetryStrategy)(payload, retryState, (payload, onResponse) => {
-                    if ((0, experimentalFeatures_1.isExperimentalFeatureEnabled)(experimentalFeatures_1.ExperimentalFeature.AVOID_FETCH_KEEPALIVE)) {
-                        fetchStrategy(endpointBuilder, payload, onResponse);
-                    }
-                    else {
-                        fetchKeepAliveStrategy(endpointBuilder, bytesLimit, 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);
-            }
-        },
-        /**
-         * Drains any payloads queued for retry by sending them via sendBeacon.
-         * This prevents data loss when the page exits while events are pending retry.
-         */
-        sendQueuedOnExit: () => {
-            let payload;
-            while ((payload = retryState.queuedPayloads.dequeue()) !== undefined) {
-                for (const endpointBuilder of endpointBuilders) {
-                    sendBeaconStrategy(endpointBuilder, bytesLimit, payload);
-                }
-            }
-        },
-    };
+* 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 * require_byteUtils.ONE_KIBI_BYTE;
+function createHttpRequest(endpointBuilders, reportError, bytesLimit = RECOMMENDED_REQUEST_BYTES_LIMIT, networkErrorRetries = 0) {
+	const observable = new require_observable.Observable();
+	const retryState = require_sendWithRetryStrategy.newRetryState(networkErrorRetries);
+	return {
+		observable,
+		send: (payload) => {
+			for (const endpointBuilder of endpointBuilders) require_sendWithRetryStrategy.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);
+		},
+		/**
+		* Drains any payloads queued for retry by sending them via sendBeacon.
+		* This prevents data loss when the page exits while events are pending retry.
+		*/
+		sendQueuedOnExit: () => {
+			let payload;
+			while ((payload = retryState.queuedPayloads.dequeue()) !== void 0) for (const endpointBuilder of endpointBuilders) sendBeaconStrategy(endpointBuilder, bytesLimit, payload);
+		}
+	};
 }
 function sendBeaconStrategy(endpointBuilder, bytesLimit, payload) {
-    const canUseBeacon = !!navigator.sendBeacon && payload.bytesCount < bytesLimit;
-    if (canUseBeacon) {
-        try {
-            const beaconUrl = endpointBuilder.build('beacon', payload);
-            const isQueued = navigator.sendBeacon(beaconUrl, payload.data);
-            if (isQueued) {
-                return;
-            }
-        }
-        catch (e) {
-            reportBeaconError(e);
-        }
-    }
-    fetchStrategy(endpointBuilder, 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;
-        (0, monitor_1.monitorError)(e);
-    }
-}
-function fetchKeepAliveStrategy(endpointBuilder, bytesLimit, payload, onResponse) {
-    const canUseKeepAlive = isKeepAliveSupported() && payload.bytesCount < bytesLimit;
-    if (canUseKeepAlive) {
-        const fetchUrl = endpointBuilder.build('fetch-keepalive', payload);
-        fetch(fetchUrl, { method: 'POST', body: payload.data, keepalive: true, mode: 'cors' })
-            .then((0, monitor_1.monitor)((response) => onResponse === null || onResponse === void 0 ? void 0 : onResponse({ status: response.status, type: response.type })))
-            .catch((0, monitor_1.monitor)(() => fetchStrategy(endpointBuilder, payload, onResponse)));
-    }
-    else {
-        fetchStrategy(endpointBuilder, payload, onResponse);
-    }
+	if (!hasReportedBeaconError) {
+		hasReportedBeaconError = true;
+		(0, _kubesense_kubesense_js_core_monitor.monitorError)(e);
+	}
 }
 function fetchStrategy(endpointBuilder, payload, onResponse) {
-    const fetchUrl = endpointBuilder.build('fetch', payload);
-    fetch(fetchUrl, { method: 'POST', body: payload.data, mode: 'cors' })
-        .then((0, monitor_1.monitor)((response) => onResponse === null || onResponse === void 0 ? void 0 : onResponse({ status: response.status, type: response.type })))
-        .catch((0, monitor_1.monitor)(() => onResponse === null || onResponse === void 0 ? void 0 : onResponse({ status: 0 })));
-}
-function isKeepAliveSupported() {
-    // Request can throw, cf https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#errors
-    try {
-        return window.Request && 'keepalive' in new Request('http://a');
-    }
-    catch (_a) {
-        return false;
-    }
+	const fetchUrl = endpointBuilder.build("fetch", payload);
+	require_fetch.fetch(fetchUrl, {
+		method: "POST",
+		body: payload.data,
+		mode: "cors"
+	}).then((0, _kubesense_kubesense_js_core_monitor.monitor)((response) => onResponse?.({
+		status: response.status,
+		type: response.type
+	}))).catch((0, _kubesense_kubesense_js_core_monitor.monitor)(() => onResponse?.({ status: 0 })));
 }
+//#endregion
+exports.RECOMMENDED_REQUEST_BYTES_LIMIT = RECOMMENDED_REQUEST_BYTES_LIMIT;
+exports.createHttpRequest = createHttpRequest;
+exports.fetchStrategy = fetchStrategy;
+
 //# sourceMappingURL=httpRequest.js.map

package/cjs/transport/httpRequest.js.map

@@ -1 +1 @@
-{"version":3,"file":"httpRequest.js","sourceRoot":"","sources":["../../src/transport/httpRequest.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"httpRequest.js","names":["ONE_KIBI_BYTE","Observable","newRetryState","monitor"],"sources":["../../src/transport/httpRequest.ts"],"sourcesContent":["import type { EndpointBuilder, TransportRetryInfo } from '@kubesense/kubesense-js-core/transport'\nimport { monitor, monitorError } from '@kubesense/kubesense-js-core/monitor'\nimport type { Context } from '../tools/serialisation/context'\nimport { fetch } from '../browser/fetch'\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  sendQueuedOnExit(this: void): 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  | {\n      // A request to send the given payload failed and will not be retried; the payload is gone.\n      // `status` is the last response's, 0 for a network error.\n      type: 'dropped'\n      bandwidth: BandwidthStats\n      payload: Body\n      status: number\n    }\n\nexport interface Payload {\n  data: string | FormData | Blob\n  bytesCount: number\n  retry?: TransportRetryInfo\n  encoding?: 'deflate'\n}\n\nexport function createHttpRequest<Body extends Payload = Payload>(\n  endpointBuilders: EndpointBuilder[],\n  reportError: (message: string) => void,\n  bytesLimit: number = RECOMMENDED_REQUEST_BYTES_LIMIT,\n  networkErrorRetries = 0\n): HttpRequest<Body> {\n  const observable = new Observable<HttpRequestEvent<Body>>()\n  const retryState = newRetryState<Body>(networkErrorRetries)\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     * Drains any payloads queued for retry by sending them via sendBeacon.\n     * This prevents data loss when the page exits while events are pending retry.\n     */\n    sendQueuedOnExit: () => {\n      let payload: Body | undefined\n      while ((payload = retryState.queuedPayloads.dequeue()) !== undefined) {\n        for (const endpointBuilder of endpointBuilders) {\n          sendBeaconStrategy(endpointBuilder, bytesLimit, payload)\n        }\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":";;;;;;;;;;AAYA,MAAa,kCAAkC,KAAKA,kBAAAA;AA+DpD,SAAgB,kBACd,kBACA,aACA,aAAqB,iCACrB,sBAAsB,GACH;CACnB,MAAM,aAAa,IAAIC,mBAAAA,WAAmC;CAC1D,MAAM,aAAaC,8BAAAA,cAAoB,mBAAmB;CAE1D,OAAO;EACL;EACA,OAAO,YAAkB;GACvB,KAAK,MAAM,mBAAmB,kBAC5B,8BAAA,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;;;;;EAKA,wBAAwB;GACtB,IAAI;GACJ,QAAQ,UAAU,WAAW,eAAe,QAAQ,OAAO,KAAA,GACzD,KAAK,MAAM,mBAAmB,kBAC5B,mBAAmB,iBAAiB,YAAY,OAAO;EAG7D;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,CAAA,GAAA,qCAAA,aAAA,CAAa,CAAC;CAChB;AACF;AAEA,SAAgB,cACd,iBACA,SACA,YACA;CACA,MAAM,WAAW,gBAAgB,MAAM,SAAS,OAAO;CAEvD,cAAA,MAAM,UAAU;EAAE,QAAQ;EAAQ,MAAM,QAAQ;EAAM,MAAM;CAAO,CAAC,CAAC,CAClE,MAAA,GAAKC,qCAAAA,QAAAA,EAAS,aAAuB,aAAa;EAAE,QAAQ,SAAS;EAAQ,MAAM,SAAS;CAAK,CAAC,CAAC,CAAC,CAAC,CACrG,OAAA,GAAMA,qCAAAA,QAAAA,OAAc,aAAa,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC;AACrD"}

package/cjs/transport/index.d.ts

@@ -1,7 +1,8 @@
-export type { BandwidthStats, HttpRequest, HttpRequestEvent, Payload, RetryInfo } from './httpRequest';
+export type { BandwidthStats, HttpRequest, HttpRequestEvent, Payload } from './httpRequest';
 export { createHttpRequest } from './httpRequest';
 export type { BrowserWindowWithEventBridge, KubeSenseEventBridge } from './eventBridge';
 export { canUseEventBridge, bridgeSupports, getEventBridge, BridgeCapability } from './eventBridge';
+export type { Batch } from './batch';
 export { createBatch } from './batch';
-export type { FlushController, FlushEvent, FlushReason } from './flushController';
+export type { FlushController, FlushEvent, FlushReason, UrgentFlushReason } from './flushController';
 export { createFlushController, FLUSH_DURATION_LIMIT } from './flushController';

package/cjs/transport/sendWithRetryStrategy.d.ts

@@ -1,5 +1,4 @@
-import type { TrackType } from '../domain/configuration';
-import type { RawError } from '../domain/error/error.types';
+import type { TrackType } from '@kubesense/kubesense-js-core/transport';
 import type { Observable } from '../tools/observable';
 import type { Payload, HttpRequestEvent, HttpResponse, BandwidthStats } from './httpRequest';
 export declare const MAX_ONGOING_BYTES_COUNT: number;
@@ -18,10 +17,16 @@ export interface RetryState<Body extends Payload> {
     bandwidthMonitor: ReturnType<typeof newBandwidthMonitor>;
     queuedPayloads: ReturnType<typeof newPayloadQueue<Body>>;
     queueFullReported: boolean;
+    /**
+     * How many times a payload is retried after a network error while the browser is online. 0 keeps
+     * such a payload from being retried at all: it is usually a blocked or CORS-rejected request that
+     * would fail forever.
+     */
+    networkErrorRetries: number;
 }
 type SendStrategy<Body extends Payload> = (payload: Body, onResponse: (r: HttpResponse) => void) => void;
-export declare function sendWithRetryStrategy<Body extends Payload>(payload: Body, state: RetryState<Body>, sendStrategy: SendStrategy<Body>, trackType: TrackType, reportError: (error: RawError) => void, requestObservable: Observable<HttpRequestEvent<Body>>): void;
-export declare function newRetryState<Body extends Payload>(): RetryState<Body>;
+export declare function sendWithRetryStrategy<Body extends Payload>(payload: Body, state: RetryState<Body>, sendStrategy: SendStrategy<Body>, trackType: TrackType, reportError: (message: string) => void, requestObservable: Observable<HttpRequestEvent<Body>>): void;
+export declare function newRetryState<Body extends Payload>(networkErrorRetries?: number): RetryState<Body>;
 declare function newPayloadQueue<Body extends Payload>(): {
     bytesCount: number;
     enqueue(payload: Body): boolean;