@loggerjs/browser 0.5.4 → 0.5.6

package/dist/index.cjs

@@ -169,8 +169,10 @@ function remainingEvents(chunks, startIndex) {
 }
 function browserHttpTransport(options) {
 	const codec = options.codec ?? (0, _loggerjs_core.safeJsonCodec)();
+	const beaconCodec = options.beaconCodec ?? codec;
 	const queue = [];
 	const maxBatchSize = options.maxBatchSize ?? 50;
+	if (!Number.isSafeInteger(maxBatchSize) || maxBatchSize <= 0) throw new RangeError("maxBatchSize must be a positive safe integer");
 	const flushIntervalMs = options.flushIntervalMs ?? 2e3;
 	const maxQueueSize = options.maxQueueSize ?? 1e3;
 	const dropPolicy = options.dropPolicy ?? "drop-oldest";
@@ -183,7 +185,8 @@ function browserHttpTransport(options) {
 	const fetchFn = options.fetchFn ?? globalThis.fetch?.bind(globalThis);
 	let offlineEntrySeq = 0;
 	let timer;
-	let flushing = false;
+	let activeFlush;
+	let flushingBeacon = false;
 	let replayingOffline = false;
 	let lastContext;
 	const headers = (payloadHeaders, contentType = codec.contentType) => ({
@@ -209,54 +212,62 @@ function browserHttpTransport(options) {
 	};
 	const createBeaconChunks = (batch) => {
 		const chunks = [];
+		const oversized = [];
 		let currentEvents = [];
 		let currentPayload;
 		for (const event of batch) {
+			if (currentEvents.length === maxBatchSize && currentPayload !== void 0) {
+				chunks.push({
+					events: currentEvents,
+					payload: currentPayload
+				});
+				currentEvents = [];
+				currentPayload = void 0;
+			}
 			const candidateEvents = [...currentEvents, event];
-			const candidatePayload = codec.encode(candidateEvents);
+			const candidatePayload = beaconCodec.encode(candidateEvents);
 			if (payloadByteLength$1(candidatePayload) <= beaconMaxBytes) {
 				currentEvents = candidateEvents;
 				currentPayload = candidatePayload;
 				continue;
 			}
-			if (currentEvents.length > 0 && currentPayload) chunks.push({
+			if (currentEvents.length > 0 && currentPayload !== void 0) chunks.push({
 				events: currentEvents,
 				payload: currentPayload
 			});
-			const singlePayload = codec.encode([event]);
+			const singlePayload = beaconCodec.encode([event]);
 			if (payloadByteLength$1(singlePayload) <= beaconMaxBytes) {
 				currentEvents = [event];
 				currentPayload = singlePayload;
 			} else {
 				currentEvents = [];
 				currentPayload = void 0;
-				reportDrop(event, "beacon-too-large");
+				oversized.push(event);
 			}
 		}
-		if (currentEvents.length > 0 && currentPayload) chunks.push({
+		if (currentEvents.length > 0 && currentPayload !== void 0) chunks.push({
 			events: currentEvents,
 			payload: currentPayload
 		});
+		for (const event of oversized) reportDrop(event, "beacon-too-large");
 		return chunks;
 	};
 	const sendBeaconBatch = (batch) => {
-		if (typeof navigator === "undefined" || !navigator.sendBeacon) return {
-			ok: false,
-			remaining: batch
-		};
+		if (typeof navigator === "undefined" || !navigator.sendBeacon) return { remaining: batch };
 		const chunks = createBeaconChunks(batch);
 		for (let index = 0; index < chunks.length; index++) {
 			const chunk = chunks[index];
 			if (!chunk) continue;
-			if (!navigator.sendBeacon(options.url, payloadToBeaconBody(chunk.payload, codec.contentType))) return {
-				ok: false,
-				remaining: remainingEvents(chunks, index)
-			};
+			try {
+				if (!navigator.sendBeacon(options.url, payloadToBeaconBody(chunk.payload, beaconCodec.contentType))) return { remaining: remainingEvents(chunks, index) };
+			} catch (error) {
+				return {
+					remaining: remainingEvents(chunks, index),
+					failure: { error }
+				};
+			}
 		}
-		return {
-			ok: true,
-			remaining: []
-		};
+		return { remaining: [] };
 	};
 	const sendPayload = async (entry) => {
 		if (!fetchFn) throw new Error("fetch is not available for browserHttpTransport");
@@ -333,31 +344,65 @@ function browserHttpTransport(options) {
 			replayingOffline = false;
 		}
 	};
-	const flush = async (preferBeacon = false) => {
-		if (flushing || queue.length === 0) return;
-		flushing = true;
-		clearTimer();
-		const batch = queue.splice(0, queue.length);
-		let pendingBatch = batch;
+	const flushBeaconQueue = () => {
+		if (flushingBeacon || options.transformPayload || queue.length === 0) return;
+		flushingBeacon = true;
+		let pending = queue.splice(0, queue.length);
 		try {
-			if (preferBeacon && !options.transformPayload) {
-				const beaconResult = sendBeaconBatch(batch);
-				if (beaconResult.ok || beaconResult.remaining.length === 0) return;
-				pendingBatch = beaconResult.remaining;
-			}
-			await sendFetchBatch(pendingBatch);
-			pendingBatch = [];
-		} catch (error) {
-			if (pendingBatch.length > 0) queue.unshift(...pendingBatch);
-			throw error;
+			const result = sendBeaconBatch(pending);
+			pending = result.remaining;
+			if (result.failure) throw result.failure.error;
 		} finally {
-			flushing = false;
-			if (queue.length > 0) schedule();
+			if (pending.length > 0) queue.unshift(...pending);
+			flushingBeacon = false;
 		}
 	};
+	const flush = (preferBeacon = false) => {
+		if (activeFlush) {
+			if (preferBeacon) try {
+				flushBeaconQueue();
+			} catch (error) {
+				return activeFlush.then(() => {
+					throw error;
+				});
+			}
+			return activeFlush;
+		}
+		if (queue.length === 0) return Promise.resolve();
+		clearTimer();
+		let resolve;
+		let reject;
+		const task = new Promise((onResolve, onReject) => {
+			resolve = onResolve;
+			reject = onReject;
+		});
+		activeFlush = task;
+		(async () => {
+			try {
+				if (preferBeacon) flushBeaconQueue();
+				while (queue.length > 0) {
+					const batch = queue.splice(0, maxBatchSize);
+					try {
+						await sendFetchBatch(batch);
+					} catch (error) {
+						queue.unshift(...batch);
+						throw error;
+					}
+				}
+				resolve();
+			} catch (error) {
+				reject(error);
+			} finally {
+				activeFlush = void 0;
+				if (queue.length > 0) schedule();
+			}
+		})();
+		return task;
+	};
 	const schedule = () => {
-		if (timer || flushIntervalMs <= 0) return;
+		if (activeFlush || timer || flushIntervalMs <= 0) return;
 		timer = setTimeout(() => {
+			timer = void 0;
 			flush(false).catch((error) => reportInternalError(error, "flush"));
 		}, flushIntervalMs);
 	};
@@ -390,6 +435,7 @@ function browserHttpTransport(options) {
 				if (dropped) reportDrop(dropped, "queue-full");
 			}
 			queue.push(event);
+			if (activeFlush) return;
 			if (queue.length >= maxBatchSize) flush(false).catch((error) => reportInternalError(error, "flush"));
 			else schedule();
 		},