@loggerjs/browser 0.5.5 → 0.6.0

package/dist/index.js

@@ -172,6 +172,7 @@ function browserHttpTransport(options) {
 	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";
@@ -184,8 +185,9 @@ function browserHttpTransport(options) {
 	const fetchFn = options.fetchFn ?? globalThis.fetch?.bind(globalThis);
 	let offlineEntrySeq = 0;
 	let timer;
-	let flushing = false;
-	let replayingOffline = false;
+	let activeFlush;
+	let flushingBeacon = false;
+	let replayPromise;
 	let lastContext;
 	const headers = (payloadHeaders, contentType = codec.contentType) => ({
 		"content-type": contentType,
@@ -210,9 +212,18 @@ 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 = beaconCodec.encode(candidateEvents);
 			if (payloadByteLength$1(candidatePayload) <= beaconMaxBytes) {
@@ -220,7 +231,7 @@ function browserHttpTransport(options) {
 				currentPayload = candidatePayload;
 				continue;
 			}
-			if (currentEvents.length > 0 && currentPayload) chunks.push({
+			if (currentEvents.length > 0 && currentPayload !== void 0) chunks.push({
 				events: currentEvents,
 				payload: currentPayload
 			});
@@ -231,33 +242,32 @@ function browserHttpTransport(options) {
 			} 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, beaconCodec.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");
@@ -293,17 +303,18 @@ function browserHttpTransport(options) {
 		incrementLoggerMetaCounter("transport.offline.queued");
 		return true;
 	};
+	const isOnline = () => typeof navigator === "undefined" || navigator.onLine !== false;
 	const sendFetchBatch = async (batch) => {
-		if (batch.length === 0) return;
 		const transformed = await encodeTransformedPayload(batch);
-		if (offlineQueue && typeof navigator !== "undefined" && navigator.onLine === false) {
+		if (offlineQueue && !isOnline()) {
 			await enqueueOfflinePayload(transformed.payload, transformed.headers, transformed.contentType);
-			return;
+			return "queued";
 		}
 		try {
 			await sendPayload(createOfflineEntry(transformed.payload, transformed.headers, transformed.contentType));
+			return "sent";
 		} catch (error) {
-			if (await enqueueOfflinePayload(transformed.payload, transformed.headers, transformed.contentType)) return;
+			if (await enqueueOfflinePayload(transformed.payload, transformed.headers, transformed.contentType)) return "queued";
 			throw error;
 		}
 	};
@@ -325,40 +336,88 @@ function browserHttpTransport(options) {
 			await sleep(replayRetryDelay(attempt));
 		}
 	};
-	const replayOfflineQueue = async () => {
-		if (!offlineQueue || replayingOffline) return;
-		replayingOffline = true;
+	const replayOfflineQueue = () => {
+		if (!offlineQueue) return Promise.resolve();
+		replayPromise ??= (async () => {
+			try {
+				await offlineQueue.replay(sendOfflineEntryWithRetry);
+			} finally {
+				replayPromise = void 0;
+			}
+		})();
+		return replayPromise;
+	};
+	const replayOfflineQueueSafely = async (operation) => {
+		if (!offlineQueue || !isOnline()) return;
 		try {
-			await offlineQueue.replay(sendOfflineEntryWithRetry);
-		} finally {
-			replayingOffline = false;
+			await replayOfflineQueue();
+		} catch (error) {
+			reportInternalError(error, operation);
 		}
 	};
-	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 preferBeacon ? Promise.resolve() : replayOfflineQueueSafely("replay");
+		clearTimer();
+		let resolve;
+		let reject;
+		const task = new Promise((onResolve, onReject) => {
+			resolve = onResolve;
+			reject = onReject;
+		});
+		activeFlush = task;
+		(async () => {
+			try {
+				if (preferBeacon) flushBeaconQueue();
+				let sent = false;
+				let queued = false;
+				while (queue.length > 0) {
+					const batch = queue.splice(0, maxBatchSize);
+					try {
+						if (await sendFetchBatch(batch) === "sent") sent = true;
+						else queued = true;
+					} catch (error) {
+						queue.unshift(...batch);
+						throw error;
+					}
+				}
+				if (!preferBeacon && sent && !queued) await replayOfflineQueueSafely("replay");
+				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);
 	};
@@ -375,7 +434,10 @@ function browserHttpTransport(options) {
 		globalThis.addEventListener?.("pagehide", onPageHide);
 		globalThis.addEventListener?.("visibilitychange", onVisibilityChange);
 	}
-	if (offlineQueue) globalThis.addEventListener?.("online", onOnline);
+	if (offlineQueue) {
+		globalThis.addEventListener?.("online", onOnline);
+		if (options.offlineReplayOnStart ?? true) setTimeout(() => void replayOfflineQueueSafely("startup-replay"), 0);
+	}
 	return {
 		name: options.name ?? "browser-http",
 		minLevel: options.minLevel,
@@ -391,6 +453,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();
 		},
@@ -2028,6 +2091,7 @@ function offlineFirstTransport(remote, options = {}) {
 		name,
 		minLevel: options.minLevel ?? remote.minLevel,
 		queue,
+		ready: remote.ready && (() => remote.ready?.()),
 		write(record, context) {
 			return sendOrQueue(context.toEvent(record), context);
 		},