@logspace/sdk 1.1.7 → 1.1.9

package/logspace.esm.js

@@ -14490,7 +14490,7 @@ async function updatePendingSessionRetry(sessionId) {
 async function cleanupOldPendingSessions() {
   if (!isIndexedDBAvailable()) return;
   const MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
-  const MAX_RETRIES = 5;
+  const MAX_RETRIES = 10;
   const now = Date.now();
   try {
     const sessions = await getPendingSessions();
@@ -14505,6 +14505,18 @@ async function cleanupOldPendingSessions() {
     console.warn("[LogSpace] Failed to cleanup old sessions:", error);
   }
 }
+function getBackoffInterval(retryCount) {
+  const baseMs = 60 * 1e3;
+  const maxMs = 60 * 60 * 1e3;
+  const backoff = Math.min(baseMs * Math.pow(2, retryCount), maxMs);
+  return backoff;
+}
+function isReadyForRetry(session2) {
+  if (!session2.lastRetryAt) return true;
+  const backoffMs = getBackoffInterval(session2.retryCount);
+  const timeSinceLastRetry = Date.now() - session2.lastRetryAt;
+  return timeSinceLastRetry >= backoffMs;
+}
 function closeDB() {
   if (db) {
     db.close();
@@ -14524,15 +14536,17 @@ let rateLimiter = { count: 0, windowStart: 0 };
 let deduplication = { lastLogHash: null, lastLogCount: 0 };
 let currentSize = 0;
 let rrwebSize = 0;
-let lastRateLimitWarningTime = 0;
-const RATE_LIMIT_WARNING_THROTTLE_MS = 1e3;
+let rateLimitWarnedThisWindow = false;
+let rateLimitDroppedCount = 0;
 let rrwebRateLimiter = { count: 0, windowStart: 0 };
 const RRWEB_RATE_LIMIT = 500;
 let idleTimer = null;
 let durationTimer = null;
 let checkpointTimer = null;
 let visibilityTimer = null;
+let pendingRetryTimer = null;
 let lastMouseMoveTime = 0;
+const PENDING_RETRY_INTERVAL = 2 * 60 * 1e3;
 let samplingTriggered = false;
 let samplingTriggerType = null;
 let samplingFirstTriggerTime = null;
@@ -14748,18 +14762,23 @@ function checkRateLimit() {
   const now = Date.now();
   const windowMs = 1e3;
   if (now - rateLimiter.windowStart > windowMs) {
+    if (config.debug && rateLimitDroppedCount > 0) {
+      console.warn(`[LogSpace] Rate limit: dropped ${rateLimitDroppedCount} logs in last second`);
+    }
     rateLimiter.windowStart = now;
     rateLimiter.count = 1;
+    rateLimitWarnedThisWindow = false;
+    rateLimitDroppedCount = 0;
     return true;
   }
   rateLimiter.count++;
   if (rateLimiter.count > config.limits.rateLimit) {
-    if (config.debug) {
-      const now2 = Date.now();
-      if (now2 - lastRateLimitWarningTime >= RATE_LIMIT_WARNING_THROTTLE_MS) {
-        lastRateLimitWarningTime = now2;
-        console.warn("[LogSpace] Rate limit exceeded, dropping log");
-      }
+    rateLimitDroppedCount++;
+    if (!rateLimitWarnedThisWindow) {
+      rateLimitWarnedThisWindow = true;
+      console.warn(
+        `[LogSpace] Rate limit exceeded (${config.limits.rateLimit}/sec). Logs are being dropped. Consider increasing limits.rateLimit or disabling noisy captures.`
+      );
     }
     return false;
   }
@@ -15187,6 +15206,48 @@ function stopCheckpointTimer() {
     checkpointTimer = null;
   }
 }
+function startPendingRetryTimer() {
+  if (pendingRetryTimer || !isIndexedDBAvailable()) return;
+  pendingRetryTimer = setInterval(async () => {
+    if (!config?.serverUrl) return;
+    try {
+      const pendingSessions = await getPendingSessions();
+      if (pendingSessions.length === 0) return;
+      const readySessions = pendingSessions.filter(isReadyForRetry);
+      if (readySessions.length === 0) return;
+      if (config.debug) {
+        console.log(
+          `[LogSpace] Periodic retry: ${readySessions.length} of ${pendingSessions.length} pending sessions ready`
+        );
+      }
+      for (const stored of readySessions) {
+        try {
+          await sendPayloadToServer(stored.data);
+          await removePendingSession(stored.id);
+          if (config.debug) {
+            console.log("[LogSpace] Pending session sent:", stored.id);
+          }
+        } catch (error) {
+          await updatePendingSessionRetry(stored.id);
+          if (config.debug) {
+            const nextBackoff = Math.ceil(getBackoffInterval(stored.retryCount + 1) / 1e3);
+            console.warn(`[LogSpace] Retry failed for ${stored.id}, next retry in ${nextBackoff}s`);
+          }
+        }
+      }
+    } catch (error) {
+      if (config?.debug) {
+        console.warn("[LogSpace] Periodic retry check failed:", error);
+      }
+    }
+  }, PENDING_RETRY_INTERVAL);
+}
+function stopPendingRetryTimer() {
+  if (pendingRetryTimer) {
+    clearInterval(pendingRetryTimer);
+    pendingRetryTimer = null;
+  }
+}
 const EMERGENCY_BACKUP_KEY = "__logspace_emergency_backup";
 const SAMPLING_STATE_KEY = "__logspace_sampling_state";
 function saveSamplingState(sessionId) {
@@ -15837,6 +15898,16 @@ async function recoverPendingSessions() {
         await removePendingSession(stored.id);
         continue;
       }
+      if (!isReadyForRetry(stored)) {
+        if (config.debug) {
+          const backoffMs = getBackoffInterval(stored.retryCount);
+          const waitTime = Math.ceil((backoffMs - (Date.now() - (stored.lastRetryAt || 0))) / 1e3);
+          console.log(
+            `[LogSpace] Pending session ${stored.id} waiting for backoff (${waitTime}s remaining, retry #${stored.retryCount})`
+          );
+        }
+        continue;
+      }
       try {
         await sendPayloadToServer(stored.data);
         processedRecoverySessionIds.add(stored.id);
@@ -15929,6 +16000,7 @@ const LogSpace = {
     }
     unloadHandled = false;
     isNavigatingAway = false;
+    startPendingRetryTimer();
     this.startSession();
     recoverPendingSessions().catch(() => {
     });
@@ -15961,7 +16033,8 @@ const LogSpace = {
     rrwebSize = 0;
     rateLimiter = { count: 0, windowStart: 0 };
     rrwebRateLimiter = { count: 0, windowStart: 0 };
-    lastRateLimitWarningTime = 0;
+    rateLimitWarnedThisWindow = false;
+    rateLimitDroppedCount = 0;
     deduplication = { lastLogHash: null, lastLogCount: 0 };
     endReason = "manual";
     let sessionId;
@@ -16299,6 +16372,7 @@ const LogSpace = {
       visibilityTimer = null;
     }
     stopCheckpointTimer();
+    stopPendingRetryTimer();
     stopSamplingTrimTimer();
     if (config?.capture.rrweb) {
       stopRRWebRecording();