ray-logger-core 0.0.4 → 0.0.6

package/index.js

@@ -484,6 +484,27 @@ function noop$4() {
     // noop
 }
 
+const BINARY_RESPONSE_BODY_PLACEHOLDER = 'arraybuffer';
+const TEXTUAL_CONTENT_TYPE_PATTERNS = [
+    /^text\//i,
+    /^application\/json(?:\s*;|$)/i,
+    /^application\/[\w.+-]+\+json(?:\s*;|$)/i,
+    /^application\/javascript(?:\s*;|$)/i,
+    /^application\/xml(?:\s*;|$)/i,
+    /^application\/[\w.+-]+\+xml(?:\s*;|$)/i,
+    /^application\/x-www-form-urlencoded(?:\s*;|$)/i,
+];
+function isTextualContentType(contentType) {
+    if (!contentType) {
+        return undefined;
+    }
+    const normalized = contentType.trim();
+    if (!normalized) {
+        return undefined;
+    }
+    return TEXTUAL_CONTENT_TYPE_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+
 function installFetchCollector(options) {
     const originalFetch = options.fetchRef ?? globalThis.fetch;
     if (typeof originalFetch !== 'function' || typeof globalThis.fetch !== 'function') {
@@ -619,6 +640,10 @@ async function readResponseBody(response, config) {
     if (config.enableRecordResponseBody === false) {
         return { bodySkippedReason: 'response-body-disabled' };
     }
+    const isTextual = isTextualContentType(response.headers.get('content-type'));
+    if (isTextual === false) {
+        return { body: BINARY_RESPONSE_BODY_PLACEHOLDER };
+    }
     try {
         return { body: await response.clone().text() };
     }
@@ -821,7 +846,11 @@ function readXhrResponseBody(xhr, config) {
         return { bodySkippedReason: 'response-body-disabled' };
     }
     if (xhr.responseType && xhr.responseType !== 'text') {
-        return { bodySkippedReason: `response-body-${xhr.responseType}` };
+        return { body: BINARY_RESPONSE_BODY_PLACEHOLDER };
+    }
+    const isTextual = isTextualContentType(xhr.getResponseHeader('content-type'));
+    if (isTextual === false) {
+        return { body: BINARY_RESPONSE_BODY_PLACEHOLDER };
     }
     try {
         return { body: xhr.responseText };
@@ -1100,6 +1129,19 @@ function hasRrwebFullSnapshot(events) {
 function isRrwebFullSnapshot(event) {
     return event.type === 'rrweb' && event.payload.rrwebEvent.type === 2;
 }
+function filterRepeatedRrwebFullSnapshotsSince(events, sinceMs) {
+    let hasWindowFullSnapshot = false;
+    return events.filter((event) => {
+        if (!isRrwebFullSnapshot(event) || event.timestamp < sinceMs) {
+            return true;
+        }
+        if (hasWindowFullSnapshot) {
+            return false;
+        }
+        hasWindowFullSnapshot = true;
+        return true;
+    });
+}
 function isRrwebFullSnapshotBefore(event, beforeMs) {
     return isRrwebFullSnapshot(event) && event.timestamp < beforeMs;
 }
@@ -1109,6 +1151,169 @@ const SESSION_META_STORE = 'sessionMeta';
 const EVENT_CHUNKS_STORE = 'eventChunks';
 const EVENT_CHUNKS_BY_NAMESPACE_MAX_TIMESTAMP_INDEX = 'byNamespaceMaxTimestamp';
 const EVENT_CHUNKS_BY_NAMESPACE_MIN_TIMESTAMP_INDEX = 'byNamespaceMinTimestamp';
+function normalizeNonNegativeNumber(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+function normalizeOptionalNonNegativeNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+async function collectNamespaceUsage(db) {
+    const meta = await collectSessionMeta(db);
+    const chunks = await collectEventChunks(db);
+    const byNamespace = new Map();
+    for (const record of meta) {
+        byNamespace.set(record.namespaceKey, {
+            namespaceKey: record.namespaceKey,
+            updatedAt: normalizeRecordUpdatedAt(record.updatedAt),
+            chunkCount: 0,
+            estimatedBytes: 0,
+        });
+    }
+    for (const chunk of chunks) {
+        const current = byNamespace.get(chunk.namespaceKey) ?? {
+            namespaceKey: chunk.namespaceKey,
+            updatedAt: 0,
+            chunkCount: 0,
+            estimatedBytes: 0,
+        };
+        current.chunkCount += 1;
+        current.estimatedBytes += estimateChunkBytes(chunk);
+        byNamespace.set(chunk.namespaceKey, current);
+    }
+    return [...byNamespace.values()];
+}
+function collectSessionMeta(db) {
+    return collectCursorValues(db.transaction(SESSION_META_STORE, 'readonly').objectStore(SESSION_META_STORE).openCursor());
+}
+function collectEventChunks(db) {
+    return collectCursorValues(db.transaction(EVENT_CHUNKS_STORE, 'readonly').objectStore(EVENT_CHUNKS_STORE).openCursor());
+}
+function collectCursorValues(request) {
+    return new Promise((resolve, reject) => {
+        const values = [];
+        request.onerror = () => reject(request.error ?? new Error('IndexedDB cursor failed.'));
+        request.onsuccess = () => {
+            const cursor = request.result;
+            if (!cursor) {
+                resolve(values);
+                return;
+            }
+            values.push(cursor.value);
+            cursor.continue();
+        };
+    });
+}
+async function deleteNamespace(db, namespaceKey) {
+    const tx = db.transaction([SESSION_META_STORE, EVENT_CHUNKS_STORE], 'readwrite');
+    tx.objectStore(SESSION_META_STORE).delete(namespaceKey);
+    const range = IDBKeyRange.bound([namespaceKey, 0], [namespaceKey, Number.MAX_SAFE_INTEGER]);
+    const store = tx.objectStore(EVENT_CHUNKS_STORE);
+    const request = store.openCursor(range);
+    request.onsuccess = () => {
+        const cursor = request.result;
+        if (!cursor) {
+            return;
+        }
+        cursor.delete();
+        cursor.continue();
+    };
+    await transactionDone(tx);
+}
+function normalizeRecordUpdatedAt(updatedAt) {
+    return Number.isFinite(updatedAt) ? updatedAt : 0;
+}
+function estimateChunkBytes(chunk) {
+    return JSON.stringify(chunk.events).length * 2;
+}
+function openDatabase(dbName) {
+    return new Promise((resolve, reject) => {
+        const request = globalThis.indexedDB.open(dbName, IDB_VERSION);
+        request.onupgradeneeded = () => {
+            const db = request.result;
+            if (!db.objectStoreNames.contains(SESSION_META_STORE)) {
+                db.createObjectStore(SESSION_META_STORE, { keyPath: 'namespaceKey' });
+            }
+            let eventChunksStore;
+            if (!db.objectStoreNames.contains(EVENT_CHUNKS_STORE)) {
+                eventChunksStore = db.createObjectStore(EVENT_CHUNKS_STORE, {
+                    keyPath: ['namespaceKey', 'chunkSeq'],
+                });
+            }
+            else {
+                eventChunksStore = request.transaction.objectStore(EVENT_CHUNKS_STORE);
+            }
+            if (!eventChunksStore.indexNames.contains(EVENT_CHUNKS_BY_NAMESPACE_MAX_TIMESTAMP_INDEX)) {
+                eventChunksStore.createIndex(EVENT_CHUNKS_BY_NAMESPACE_MAX_TIMESTAMP_INDEX, [
+                    'namespaceKey',
+                    'maxTimestamp',
+                ]);
+            }
+            if (!eventChunksStore.indexNames.contains(EVENT_CHUNKS_BY_NAMESPACE_MIN_TIMESTAMP_INDEX)) {
+                eventChunksStore.createIndex(EVENT_CHUNKS_BY_NAMESPACE_MIN_TIMESTAMP_INDEX, [
+                    'namespaceKey',
+                    'minTimestamp',
+                ]);
+            }
+        };
+        request.onerror = () => reject(request.error ?? new Error('Failed to open IndexedDB.'));
+        request.onsuccess = () => resolve(request.result);
+    });
+}
+function requestToPromise(request) {
+    return new Promise((resolve, reject) => {
+        request.onerror = () => reject(request.error ?? new Error('IndexedDB request failed.'));
+        request.onsuccess = () => resolve(request.result);
+    });
+}
+function transactionDone(transaction) {
+    return new Promise((resolve, reject) => {
+        transaction.oncomplete = () => resolve();
+        transaction.onerror = () => reject(transaction.error ?? new Error('IndexedDB transaction failed.'));
+        transaction.onabort = () => reject(transaction.error ?? new Error('IndexedDB transaction aborted.'));
+    });
+}
+function collectEventsCursor(request, options) {
+    return new Promise((resolve, reject) => {
+        const values = [];
+        const sinceMs = options.sinceMs ?? Number.NEGATIVE_INFINITY;
+        const untilMs = options.untilMs ?? Number.POSITIVE_INFINITY;
+        request.onerror = () => reject(request.error ?? new Error('IndexedDB cursor failed.'));
+        request.onsuccess = () => {
+            const cursor = request.result;
+            if (!cursor) {
+                resolve(values);
+                return;
+            }
+            const chunk = cursor.value;
+            for (const event of chunk.events) {
+                if (event.timestamp >= sinceMs && event.timestamp <= untilMs) {
+                    values.push(event);
+                }
+            }
+            cursor.continue();
+        };
+    });
+}
+function findLatestRrwebFullSnapshotCursor(request, beforeMs) {
+    return new Promise((resolve, reject) => {
+        request.onerror = () => reject(request.error ?? new Error('IndexedDB cursor failed.'));
+        request.onsuccess = () => {
+            const cursor = request.result;
+            if (!cursor) {
+                resolve(undefined);
+                return;
+            }
+            const chunk = cursor.value;
+            const snapshot = latestRrwebFullSnapshotBefore(chunk.events, beforeMs);
+            if (snapshot) {
+                resolve(snapshot);
+                return;
+            }
+            cursor.continue();
+        };
+    });
+}
+
 class IndexedDbEventStore {
     namespaceKey;
     dbName;
@@ -1276,168 +1481,6 @@ function emptyCleanupResult() {
         chunksAfter: 0,
     };
 }
-function normalizeNonNegativeNumber(value, fallback) {
-    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : fallback;
-}
-function normalizeOptionalNonNegativeNumber(value) {
-    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
-}
-async function collectNamespaceUsage(db) {
-    const meta = await collectSessionMeta(db);
-    const chunks = await collectEventChunks(db);
-    const byNamespace = new Map();
-    for (const record of meta) {
-        byNamespace.set(record.namespaceKey, {
-            namespaceKey: record.namespaceKey,
-            updatedAt: normalizeRecordUpdatedAt(record.updatedAt),
-            chunkCount: 0,
-            estimatedBytes: 0,
-        });
-    }
-    for (const chunk of chunks) {
-        const current = byNamespace.get(chunk.namespaceKey) ?? {
-            namespaceKey: chunk.namespaceKey,
-            updatedAt: 0,
-            chunkCount: 0,
-            estimatedBytes: 0,
-        };
-        current.chunkCount += 1;
-        current.estimatedBytes += estimateChunkBytes(chunk);
-        byNamespace.set(chunk.namespaceKey, current);
-    }
-    return [...byNamespace.values()];
-}
-function collectSessionMeta(db) {
-    return collectCursorValues(db.transaction(SESSION_META_STORE, 'readonly').objectStore(SESSION_META_STORE).openCursor());
-}
-function collectEventChunks(db) {
-    return collectCursorValues(db.transaction(EVENT_CHUNKS_STORE, 'readonly').objectStore(EVENT_CHUNKS_STORE).openCursor());
-}
-function collectCursorValues(request) {
-    return new Promise((resolve, reject) => {
-        const values = [];
-        request.onerror = () => reject(request.error ?? new Error('IndexedDB cursor failed.'));
-        request.onsuccess = () => {
-            const cursor = request.result;
-            if (!cursor) {
-                resolve(values);
-                return;
-            }
-            values.push(cursor.value);
-            cursor.continue();
-        };
-    });
-}
-async function deleteNamespace(db, namespaceKey) {
-    const tx = db.transaction([SESSION_META_STORE, EVENT_CHUNKS_STORE], 'readwrite');
-    tx.objectStore(SESSION_META_STORE).delete(namespaceKey);
-    const range = IDBKeyRange.bound([namespaceKey, 0], [namespaceKey, Number.MAX_SAFE_INTEGER]);
-    const store = tx.objectStore(EVENT_CHUNKS_STORE);
-    const request = store.openCursor(range);
-    request.onsuccess = () => {
-        const cursor = request.result;
-        if (!cursor) {
-            return;
-        }
-        cursor.delete();
-        cursor.continue();
-    };
-    await transactionDone(tx);
-}
-function normalizeRecordUpdatedAt(updatedAt) {
-    return Number.isFinite(updatedAt) ? updatedAt : 0;
-}
-function estimateChunkBytes(chunk) {
-    return JSON.stringify(chunk.events).length * 2;
-}
-function openDatabase(dbName) {
-    return new Promise((resolve, reject) => {
-        const request = globalThis.indexedDB.open(dbName, IDB_VERSION);
-        request.onupgradeneeded = () => {
-            const db = request.result;
-            if (!db.objectStoreNames.contains(SESSION_META_STORE)) {
-                db.createObjectStore(SESSION_META_STORE, { keyPath: 'namespaceKey' });
-            }
-            let eventChunksStore;
-            if (!db.objectStoreNames.contains(EVENT_CHUNKS_STORE)) {
-                eventChunksStore = db.createObjectStore(EVENT_CHUNKS_STORE, {
-                    keyPath: ['namespaceKey', 'chunkSeq'],
-                });
-            }
-            else {
-                eventChunksStore = request.transaction.objectStore(EVENT_CHUNKS_STORE);
-            }
-            if (!eventChunksStore.indexNames.contains(EVENT_CHUNKS_BY_NAMESPACE_MAX_TIMESTAMP_INDEX)) {
-                eventChunksStore.createIndex(EVENT_CHUNKS_BY_NAMESPACE_MAX_TIMESTAMP_INDEX, [
-                    'namespaceKey',
-                    'maxTimestamp',
-                ]);
-            }
-            if (!eventChunksStore.indexNames.contains(EVENT_CHUNKS_BY_NAMESPACE_MIN_TIMESTAMP_INDEX)) {
-                eventChunksStore.createIndex(EVENT_CHUNKS_BY_NAMESPACE_MIN_TIMESTAMP_INDEX, [
-                    'namespaceKey',
-                    'minTimestamp',
-                ]);
-            }
-        };
-        request.onerror = () => reject(request.error ?? new Error('Failed to open IndexedDB.'));
-        request.onsuccess = () => resolve(request.result);
-    });
-}
-function requestToPromise(request) {
-    return new Promise((resolve, reject) => {
-        request.onerror = () => reject(request.error ?? new Error('IndexedDB request failed.'));
-        request.onsuccess = () => resolve(request.result);
-    });
-}
-function transactionDone(transaction) {
-    return new Promise((resolve, reject) => {
-        transaction.oncomplete = () => resolve();
-        transaction.onerror = () => reject(transaction.error ?? new Error('IndexedDB transaction failed.'));
-        transaction.onabort = () => reject(transaction.error ?? new Error('IndexedDB transaction aborted.'));
-    });
-}
-function collectEventsCursor(request, options) {
-    return new Promise((resolve, reject) => {
-        const values = [];
-        const sinceMs = options.sinceMs ?? Number.NEGATIVE_INFINITY;
-        const untilMs = options.untilMs ?? Number.POSITIVE_INFINITY;
-        request.onerror = () => reject(request.error ?? new Error('IndexedDB cursor failed.'));
-        request.onsuccess = () => {
-            const cursor = request.result;
-            if (!cursor) {
-                resolve(values);
-                return;
-            }
-            const chunk = cursor.value;
-            for (const event of chunk.events) {
-                if (event.timestamp >= sinceMs && event.timestamp <= untilMs) {
-                    values.push(event);
-                }
-            }
-            cursor.continue();
-        };
-    });
-}
-function findLatestRrwebFullSnapshotCursor(request, beforeMs) {
-    return new Promise((resolve, reject) => {
-        request.onerror = () => reject(request.error ?? new Error('IndexedDB cursor failed.'));
-        request.onsuccess = () => {
-            const cursor = request.result;
-            if (!cursor) {
-                resolve(undefined);
-                return;
-            }
-            const chunk = cursor.value;
-            const snapshot = latestRrwebFullSnapshotBefore(chunk.events, beforeMs);
-            if (snapshot) {
-                resolve(snapshot);
-                return;
-            }
-            cursor.continue();
-        };
-    });
-}
 
 function resolveSession(options) {
     const storage = getSessionStorage();
@@ -1581,7 +1624,7 @@ class WebLoggerCoreController {
         this.#estimatedBufferBytes += estimateEventBytes(recorded);
         if (this.#estimatedBufferBytes >= this.config.memoryFlushThresholdBytes) {
             void this.flushToIdb().catch(() => {
-                // Export still includes memory events if background persistence fails.
+                // Flush errors are exposed through onFlushError and must not break host app execution.
             });
         }
         return recorded;
@@ -1589,7 +1632,7 @@ class WebLoggerCoreController {
     async flushToIdb() {
         this.#assertActive();
         if (!this.#store) {
-            return;
+            return this.#notifyFlushSuccess({ status: 'skipped', reason: 'indexeddb-unavailable' });
         }
         await this.#waitUntilReady();
         if (this.#flushPromise) {
@@ -1597,13 +1640,18 @@ class WebLoggerCoreController {
         }
         const pendingEvents = this.#timeline.pending();
         if (pendingEvents.length === 0) {
-            return;
+            return this.#notifyFlushSuccess({ status: 'skipped', reason: 'empty' });
         }
         this.#flushPromise = this.#store
             .appendChunk(pendingEvents)
-            .then(() => {
+            .then((chunk) => {
             this.#timeline.clear(pendingEvents);
             this.#estimatedBufferBytes = estimateEventsBytes(this.#timeline.pending());
+            return this.#notifyFlushSuccess(chunk ? createFlushResult(chunk) : { status: 'skipped', reason: 'empty' });
+        })
+            .catch((error) => {
+            this.#notifyFlushError(error);
+            throw error;
         })
             .finally(() => {
             this.#flushPromise = undefined;
@@ -1628,7 +1676,8 @@ class WebLoggerCoreController {
         const rrwebAnchor = hasRrwebFullSnapshot(windowEvents)
             ? undefined
             : await this.#readLatestRrwebFullSnapshotBefore(sinceMs);
-        const events = rrwebAnchor ? mergeEvents([rrwebAnchor], windowEvents) : windowEvents;
+        const mergedEvents = rrwebAnchor ? mergeEvents([rrwebAnchor], windowEvents) : windowEvents;
+        const events = filterRepeatedRrwebFullSnapshotsSince(mergedEvents, sinceMs);
         const includesRrwebBaseline = hasRrwebFullSnapshot(events);
         return this.#createExport('since', events, {
             sinceMs,
@@ -1677,6 +1726,23 @@ class WebLoggerCoreController {
             await this.#flushPromise;
         }
     }
+    #notifyFlushSuccess(result) {
+        try {
+            this.config.onFlushSuccess?.(result);
+        }
+        catch {
+            // Flush observer errors must not affect recording or export flow.
+        }
+        return result;
+    }
+    #notifyFlushError(error) {
+        try {
+            this.config.onFlushError?.(error);
+        }
+        catch {
+            // Flush observer errors must not mask the original flush failure.
+        }
+    }
     async #waitUntilReady() {
         await this.#readyPromise;
     }
@@ -1741,6 +1807,19 @@ function estimateEventBytes(event) {
 function estimateEventsBytes(events) {
     return events.reduce((total, event) => total + estimateEventBytes(event), 0);
 }
+function createFlushResult(chunk) {
+    return {
+        status: 'flushed',
+        namespaceKey: chunk.namespaceKey,
+        chunkSeq: chunk.chunkSeq,
+        eventCount: chunk.events.length,
+        minSeq: chunk.minSeq,
+        maxSeq: chunk.maxSeq,
+        minTimestamp: chunk.minTimestamp,
+        maxTimestamp: chunk.maxTimestamp,
+        estimatedBytes: estimateEventsBytes(chunk.events),
+    };
+}
 function mergeEvents(persistedEvents, memoryEvents) {
     const bySeq = new Map();
     for (const event of persistedEvents) {