@statsig/client-core 3.31.2-beta.2 → 3.32.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statsig/client-core",
-  "version": "3.31.2-beta.2",
+  "version": "3.32.0",
   "license": "ISC",
   "homepage": "https://github.com/statsig-io/js-client-monorepo",
   "repository": {

package/src/BatchedEventsQueue.d.ts

@@ -0,0 +1,14 @@
+import { EventBatch } from './EventBatch';
+import { StatsigEventInternal } from './StatsigEvent';
+export declare class BatchQueue {
+    private _batches;
+    private _batchSize;
+    constructor(batchSize?: number);
+    batchSize(): number;
+    requeueBatch(batch: EventBatch): number;
+    hasFullBatch(): boolean;
+    takeNextBatch(): EventBatch | undefined;
+    takeAllBatches(): EventBatch[];
+    createBatches(events: StatsigEventInternal[]): number;
+    private _enqueueBatch;
+}

package/src/BatchedEventsQueue.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchQueue = void 0;
+const EventBatch_1 = require("./EventBatch");
+const EventRetryConstants_1 = require("./EventRetryConstants");
+class BatchQueue {
+    constructor(batchSize = EventRetryConstants_1.EventRetryConstants.DEFAULT_BATCH_SIZE) {
+        this._batches = [];
+        this._batchSize = batchSize;
+    }
+    batchSize() {
+        return this._batchSize;
+    }
+    requeueBatch(batch) {
+        return this._enqueueBatch(batch);
+    }
+    hasFullBatch() {
+        return this._batches.some((batch) => batch.events.length >= this._batchSize);
+    }
+    takeNextBatch() {
+        return this._batches.shift();
+    }
+    takeAllBatches() {
+        const batches = this._batches;
+        this._batches = [];
+        return batches;
+    }
+    createBatches(events) {
+        let i = 0;
+        let droppedCount = 0;
+        while (i < events.length) {
+            const chunk = events.slice(i, i + this._batchSize);
+            droppedCount += this._enqueueBatch(new EventBatch_1.EventBatch(chunk));
+            i += this._batchSize;
+        }
+        return droppedCount;
+    }
+    _enqueueBatch(batch) {
+        this._batches.push(batch);
+        let droppedEventCount = 0;
+        while (this._batches.length > EventRetryConstants_1.EventRetryConstants.MAX_PENDING_BATCHES) {
+            const dropped = this._batches.shift();
+            if (dropped) {
+                droppedEventCount += dropped.events.length;
+            }
+        }
+        return droppedEventCount;
+    }
+}
+exports.BatchQueue = BatchQueue;

package/src/DownloadConfigSpecsResponse.d.ts

@@ -1,18 +1,5 @@
-import type { SessionReplayPrivacySettings } from './InitializeResponse';
 import { ParamStoreConfig } from './ParamStoreTypes';
 import { StatsigUser } from './StatsigUser';
-export type SessionReplayTriggerSpec = {
-    values?: string[];
-    sampling_rate?: number;
-};
-export type SessionReplayInfoSpec = {
-    recording_blocked?: boolean;
-    sampling_rate?: number;
-    targeting_gate?: string;
-    session_recording_event_triggers?: Record<string, SessionReplayTriggerSpec>;
-    session_recording_exposure_triggers?: Record<string, SessionReplayTriggerSpec>;
-    session_recording_privacy_settings?: SessionReplayPrivacySettings;
-};
 export type SpecCondition = {
     type: string;
     targetValue: unknown;
@@ -71,5 +58,4 @@ export type DownloadConfigSpecsResponse = {
         experiments: string[];
     }>;
     app_id?: string;
-    session_replay_info?: SessionReplayInfoSpec;
 };

package/src/ErrorBoundary.d.ts

@@ -10,6 +10,8 @@ export declare class ErrorBoundary {
     constructor(_sdkKey: string, _options: AnyStatsigOptions | null, _emitter?: StatsigClientEmitEventFunc | undefined, _lastSeenError?: Error | undefined);
     wrap(instance: unknown, namePrefix?: string): void;
     logError(tag: string, error: unknown): void;
+    logDroppedEvents(count: number, reason: string, metadata?: Record<string, unknown>): void;
+    logEventRequestFailure(count: number, reason: string, flushType: string, statusCode: number, retries: number): void;
     getLastSeenErrorAndReset(): Error | null;
     attachErrorIfNoneExists(error: unknown): void;
     private _capture;

package/src/ErrorBoundary.js

@@ -44,6 +44,27 @@ class ErrorBoundary {
     logError(tag, error) {
         this._onError(tag, error);
     }
+    logDroppedEvents(count, reason, metadata) {
+        const extra = {
+            eventCount: String(count),
+        };
+        if (metadata) {
+            Object.keys(metadata).forEach((key) => {
+                extra[key] = String(metadata[key]);
+            });
+        }
+        this._onError(`statsig::log_event_dropped_event_count`, new Error(reason), true, extra);
+    }
+    logEventRequestFailure(count, reason, flushType, statusCode, retries) {
+        const extra = {
+            eventCount: String(count),
+            flushType: flushType,
+            statusCode: String(statusCode),
+            reason: reason,
+            retries: String(retries),
+        };
+        this._onError(`statsig::log_event_failed`, new Error(reason), true, extra);
+    }
     getLastSeenErrorAndReset() {
         const tempError = this._lastSeenError;
         this._lastSeenError = undefined;
@@ -68,7 +89,7 @@ class ErrorBoundary {
             return null;
         }
     }
-    _onError(tag, error) {
+    _onError(tag, error, bypassDedupe = false, extra) {
         try {
             Log_1.Log.warn(`Caught error in ${tag}`, { error });
             const impl = () => __awaiter(this, void 0, void 0, function* () {
@@ -78,7 +99,7 @@ class ErrorBoundary {
                 const name = isError ? unwrapped.name : 'No Name';
                 const resolvedError = _resolveError(unwrapped);
                 this._lastSeenError = resolvedError;
-                if (this._seen.has(name)) {
+                if (!bypassDedupe && this._seen.has(name)) {
                     return;
                 }
                 this._seen.add(name);
@@ -93,7 +114,7 @@ class ErrorBoundary {
                 const sdkType = SDKType_1.SDKType._get(this._sdkKey);
                 const statsigMetadata = StatsigMetadata_1.StatsigMetadataProvider.get();
                 const info = isError ? unwrapped.stack : _getDescription(unwrapped);
-                const body = Object.assign({ tag, exception: name, info, statsigOptions: _getStatsigOptionLoggingCopy(this._options) }, Object.assign(Object.assign({}, statsigMetadata), { sdkType }));
+                const body = Object.assign(Object.assign({ tag, exception: name, info, statsigOptions: _getStatsigOptionLoggingCopy(this._options) }, Object.assign(Object.assign({}, statsigMetadata), { sdkType })), (extra !== null && extra !== void 0 ? extra : {}));
                 const func = (_f = (_e = (_d = this._options) === null || _d === void 0 ? void 0 : _d.networkConfig) === null || _e === void 0 ? void 0 : _e.networkOverrideFunc) !== null && _f !== void 0 ? _f : fetch;
                 yield func(exports.EXCEPTION_ENDPOINT, {
                     method: 'POST',

package/src/EventLogger.d.ts

@@ -1,3 +1,4 @@
+import { ErrorBoundary } from './ErrorBoundary';
 import { NetworkCore } from './NetworkCore';
 import { StatsigClientEmitEventFunc } from './StatsigClientBase';
 import { StatsigEventInternal } from './StatsigEvent';
@@ -7,18 +8,19 @@ export declare class EventLogger {
     private _emitter;
     private _network;
     private _options;
-    private _queue;
-    private _flushIntervalId;
+    private _errorBoundary;
+    private _pendingEvents;
+    private _batchQueue;
+    private _flushCoordinator;
     private _lastExposureTimeMap;
     private _nonExposedChecks;
-    private _maxQueueSize;
-    private _hasRunQuickFlush;
-    private _creationTime;
     private _loggingEnabled;
     private _logEventUrlConfig;
+    private _isShuttingDown;
+    private _storageKey;
+    private _pendingCompressionMode;
     private static _safeFlushAndForget;
-    private static _safeRetryFailedLogs;
-    constructor(_sdkKey: string, _emitter: StatsigClientEmitEventFunc, _network: NetworkCore, _options: StatsigOptionsCommon<NetworkConfigCommon> | null);
+    constructor(_sdkKey: string, _emitter: StatsigClientEmitEventFunc, _network: NetworkCore, _options: StatsigOptionsCommon<NetworkConfigCommon> | null, _errorBoundary: ErrorBoundary);
     setLogEventCompressionMode(mode: LogEventCompressionMode): void;
     setLoggingEnabled(loggingEnabled: LoggingEnabledOption): void;
     enqueue(event: StatsigEventInternal): void;
@@ -27,22 +29,13 @@ export declare class EventLogger {
     start(): void;
     stop(): Promise<void>;
     flush(): Promise<void>;
-    /**
-     * We 'Quick Flush' following the very first event enqueued
-     * within the quick flush window
-     */
-    private _quickFlushIfNeeded;
+    appendAndResetNonExposedChecks(): void;
     private _shouldLogEvent;
-    private _sendEvents;
-    private _sendEventsViaPost;
-    private _sendEventsViaBeacon;
-    private _getRequestData;
-    private _saveFailedLogsToStorage;
-    private _getFailedLogsFromStorage;
-    private _retryFailedLogs;
-    private _getStorageKey;
-    private _normalizeAndAppendEvent;
-    private _appendAndResetNonExposedChecks;
     private _getCurrentPageUrl;
-    private _startBackgroundFlushInterval;
+    private _getStorageKey;
+    private _initFlushCoordinator;
+    private _storeEventToStorage;
+    private _getEventsFromStorage;
+    private _loadStoredEvents;
+    private _normalizeEvent;
 }

package/src/EventLogger.js

@@ -10,23 +10,22 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventLogger = void 0;
+const BatchedEventsQueue_1 = require("./BatchedEventsQueue");
 const CacheKey_1 = require("./CacheKey");
+const EventRetryConstants_1 = require("./EventRetryConstants");
+const FlushCoordinator_1 = require("./FlushCoordinator");
 const Hashing_1 = require("./Hashing");
 const Log_1 = require("./Log");
 const NetworkConfig_1 = require("./NetworkConfig");
+const PendingEvents_1 = require("./PendingEvents");
 const SafeJs_1 = require("./SafeJs");
-const SessionID_1 = require("./SessionID");
 const StatsigEvent_1 = require("./StatsigEvent");
 const StatsigOptionsCommon_1 = require("./StatsigOptionsCommon");
 const StorageProvider_1 = require("./StorageProvider");
 const UrlConfiguration_1 = require("./UrlConfiguration");
 const VisibilityObserving_1 = require("./VisibilityObserving");
-const DEFAULT_QUEUE_SIZE = 100;
-const DEFAULT_FLUSH_INTERVAL_MS = 10000;
 const MAX_DEDUPER_KEYS = 1000;
 const DEDUPER_WINDOW_DURATION_MS = 600000;
-const MAX_FAILED_LOGS = 500;
-const QUICK_FLUSH_WINDOW_MS = 200;
 const EVENT_LOGGER_MAP = {};
 class EventLogger {
     static _safeFlushAndForget(sdkKey) {
@@ -35,21 +34,21 @@ class EventLogger {
             // noop
         });
     }
-    static _safeRetryFailedLogs(sdkKey) {
+    constructor(_sdkKey, _emitter, _network, _options, _errorBoundary) {
         var _a;
-        (_a = EVENT_LOGGER_MAP[sdkKey]) === null || _a === void 0 ? void 0 : _a._retryFailedLogs();
-    }
-    constructor(_sdkKey, _emitter, _network, _options) {
-        var _a, _b;
         this._sdkKey = _sdkKey;
         this._emitter = _emitter;
         this._network = _network;
         this._options = _options;
-        this._queue = [];
+        this._errorBoundary = _errorBoundary;
+        this._pendingEvents = null;
+        this._batchQueue = null;
+        this._flushCoordinator = null;
         this._lastExposureTimeMap = {};
         this._nonExposedChecks = {};
-        this._hasRunQuickFlush = false;
-        this._creationTime = Date.now();
+        this._isShuttingDown = false;
+        this._storageKey = null;
+        this._pendingCompressionMode = null;
         this._loggingEnabled =
             (_a = _options === null || _options === void 0 ? void 0 : _options.loggingEnabled) !== null && _a !== void 0 ? _a : ((_options === null || _options === void 0 ? void 0 : _options.disableLogging) === true
                 ? StatsigOptionsCommon_1.LoggingEnabledOption.disabled
@@ -57,34 +56,49 @@ class EventLogger {
         if ((_options === null || _options === void 0 ? void 0 : _options.loggingEnabled) && _options.disableLogging !== undefined) {
             Log_1.Log.warn('Detected both loggingEnabled and disableLogging options. loggingEnabled takes precedence - please remove disableLogging.');
         }
-        this._maxQueueSize = (_b = _options === null || _options === void 0 ? void 0 : _options.loggingBufferMaxSize) !== null && _b !== void 0 ? _b : DEFAULT_QUEUE_SIZE;
         const config = _options === null || _options === void 0 ? void 0 : _options.networkConfig;
         this._logEventUrlConfig = new UrlConfiguration_1.UrlConfiguration(NetworkConfig_1.Endpoint._rgstr, config === null || config === void 0 ? void 0 : config.logEventUrl, config === null || config === void 0 ? void 0 : config.api, config === null || config === void 0 ? void 0 : config.logEventFallbackUrls);
     }
     setLogEventCompressionMode(mode) {
-        this._network.setLogEventCompressionMode(mode);
+        if (this._flushCoordinator) {
+            this._flushCoordinator.setLogEventCompressionMode(mode);
+        }
+        else {
+            this._pendingCompressionMode = mode;
+        }
     }
     setLoggingEnabled(loggingEnabled) {
-        if (this._loggingEnabled === 'disabled' && loggingEnabled !== 'disabled') {
-            // load any pre consented events into memory
-            const storageKey = this._getStorageKey();
-            const events = (0, StorageProvider_1._getObjectFromStorage)(storageKey);
-            if (events) {
-                this._queue.push(...events);
+        const wasDisabled = this._loggingEnabled === 'disabled';
+        const isNowEnabled = loggingEnabled !== 'disabled';
+        this._loggingEnabled = loggingEnabled;
+        if (this._flushCoordinator) {
+            this._flushCoordinator.setLoggingEnabled(loggingEnabled);
+        }
+        if (wasDisabled && isNowEnabled) {
+            const events = this._loadStoredEvents();
+            Log_1.Log.debug(`Loaded ${events.length} stored event(s) from storage`);
+            if (events.length > 0) {
+                events.forEach((event) => {
+                    this._initFlushCoordinator().addEvent(event);
+                });
+                this.flush().catch((error) => {
+                    Log_1.Log.warn('Failed to flush events after enabling logging:', error);
+                });
             }
-            StorageProvider_1.Storage.removeItem(storageKey);
         }
-        this._loggingEnabled = loggingEnabled;
     }
     enqueue(event) {
+        var _a;
         if (!this._shouldLogEvent(event)) {
             return;
         }
-        this._normalizeAndAppendEvent(event);
-        this._quickFlushIfNeeded();
-        if (this._queue.length > this._maxQueueSize) {
-            EventLogger._safeFlushAndForget(this._sdkKey);
+        const normalizedEvent = this._normalizeEvent(event);
+        if (this._loggingEnabled === 'disabled') {
+            this._storeEventToStorage(normalizedEvent);
+            return;
         }
+        this._initFlushCoordinator().addEvent(normalizedEvent);
+        (_a = this._flushCoordinator) === null || _a === void 0 ? void 0 : _a.checkQuickFlush();
     }
     incrementNonExposureCount(name) {
         var _a;
@@ -104,6 +118,7 @@ class EventLogger {
         if (isServerEnv && ((_a = this._options) === null || _a === void 0 ? void 0 : _a.loggingEnabled) !== 'always') {
             return;
         }
+        const flushCoordinator = this._initFlushCoordinator();
         EVENT_LOGGER_MAP[this._sdkKey] = this;
         if (!isServerEnv) {
             (0, VisibilityObserving_1._subscribeToVisiblityChanged)((visibility) => {
@@ -111,47 +126,53 @@ class EventLogger {
                     EventLogger._safeFlushAndForget(this._sdkKey);
                 }
                 else if (visibility === 'foreground') {
-                    EventLogger._safeRetryFailedLogs(this._sdkKey);
+                    flushCoordinator.startScheduledFlushCycle();
                 }
             });
         }
-        this._retryFailedLogs();
-        this._startBackgroundFlushInterval();
+        flushCoordinator.loadAndRetryShutdownFailedEvents().catch((error) => {
+            Log_1.Log.warn('Failed to load failed shutdown events:', error);
+        });
+        flushCoordinator.startScheduledFlushCycle();
     }
     stop() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this._flushIntervalId) {
-                clearInterval(this._flushIntervalId);
-                this._flushIntervalId = null;
+            this._isShuttingDown = true;
+            if (this._flushCoordinator) {
+                yield this._flushCoordinator.processShutdown();
             }
             delete EVENT_LOGGER_MAP[this._sdkKey];
-            yield this.flush();
+            this._flushCoordinator = null;
+            this._pendingEvents = null;
+            this._batchQueue = null;
         });
     }
     flush() {
         return __awaiter(this, void 0, void 0, function* () {
-            this._appendAndResetNonExposedChecks();
-            if (this._queue.length === 0) {
+            if (!this._flushCoordinator) {
                 return;
             }
-            const events = this._queue;
-            this._queue = [];
-            yield this._sendEvents(events);
+            return this._flushCoordinator.processManualFlush();
         });
     }
-    /**
-     * We 'Quick Flush' following the very first event enqueued
-     * within the quick flush window
-     */
-    _quickFlushIfNeeded() {
-        if (this._hasRunQuickFlush) {
+    appendAndResetNonExposedChecks() {
+        if (Object.keys(this._nonExposedChecks).length === 0) {
             return;
         }
-        this._hasRunQuickFlush = true;
-        if (Date.now() - this._creationTime > QUICK_FLUSH_WINDOW_MS) {
+        const checks = Object.assign({}, this._nonExposedChecks);
+        this._nonExposedChecks = {};
+        const event = this._normalizeEvent({
+            eventName: 'statsig::non_exposed_checks',
+            user: null,
+            time: Date.now(),
+            metadata: {
+                checks,
+            },
+        });
+        if (!this._flushCoordinator) {
             return;
         }
-        setTimeout(() => EventLogger._safeFlushAndForget(this._sdkKey), QUICK_FLUSH_WINDOW_MS);
+        this._flushCoordinator.addEvent(event);
     }
     _shouldLogEvent(event) {
         var _a;
@@ -186,118 +207,69 @@ class EventLogger {
         this._lastExposureTimeMap[key] = now;
         return true;
     }
-    _sendEvents(events) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            if (this._loggingEnabled === 'disabled') {
-                this._saveFailedLogsToStorage(events);
-                return false;
-            }
-            try {
-                const isClosing = (0, VisibilityObserving_1._isUnloading)();
-                const shouldUseBeacon = isClosing &&
-                    this._network.isBeaconSupported() &&
-                    ((_b = (_a = this._options) === null || _a === void 0 ? void 0 : _a.networkConfig) === null || _b === void 0 ? void 0 : _b.networkOverrideFunc) == null;
-                this._emitter({
-                    name: 'pre_logs_flushed',
-                    events,
-                });
-                const response = shouldUseBeacon
-                    ? this._sendEventsViaBeacon(events)
-                    : yield this._sendEventsViaPost(events);
-                if (response.success) {
-                    this._emitter({
-                        name: 'logs_flushed',
-                        events,
-                    });
-                    return true;
-                }
-                else {
-                    Log_1.Log.warn('Failed to flush events.');
-                    this._saveFailedLogsToStorage(events);
-                    return false;
-                }
-            }
-            catch (_c) {
-                Log_1.Log.warn('Failed to flush events.');
-                return false;
-            }
-        });
-    }
-    _sendEventsViaPost(events) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const result = yield this._network.post(this._getRequestData(events));
-            const code = (_a = result === null || result === void 0 ? void 0 : result.code) !== null && _a !== void 0 ? _a : -1;
-            return { success: code >= 200 && code < 300 };
-        });
-    }
-    _sendEventsViaBeacon(events) {
-        return {
-            success: this._network.beacon(this._getRequestData(events)),
-        };
+    _getCurrentPageUrl() {
+        var _a;
+        if (((_a = this._options) === null || _a === void 0 ? void 0 : _a.includeCurrentPageUrlWithEvents) === false) {
+            return;
+        }
+        return (0, SafeJs_1._getCurrentPageUrlSafe)();
     }
-    _getRequestData(events) {
-        return {
-            sdkKey: this._sdkKey,
-            data: {
-                events,
-            },
-            urlConfig: this._logEventUrlConfig,
-            retries: 3,
-            isCompressable: true,
-            params: {
-                [NetworkConfig_1.NetworkParam.EventCount]: String(events.length),
-            },
-            credentials: 'same-origin',
-        };
+    _getStorageKey() {
+        if (!this._storageKey) {
+            this._storageKey = `statsig.pending_events.${(0, Hashing_1._DJB2)(this._sdkKey)}`;
+        }
+        return this._storageKey;
     }
-    _saveFailedLogsToStorage(events) {
-        while (events.length > MAX_FAILED_LOGS) {
-            events.shift();
+    _initFlushCoordinator() {
+        var _a, _b;
+        if (this._flushCoordinator) {
+            return this._flushCoordinator;
+        }
+        const batchSize = (_b = (_a = this._options) === null || _a === void 0 ? void 0 : _a.loggingBufferMaxSize) !== null && _b !== void 0 ? _b : EventRetryConstants_1.EventRetryConstants.DEFAULT_BATCH_SIZE;
+        this._pendingEvents = new PendingEvents_1.PendingEvents(batchSize);
+        this._batchQueue = new BatchedEventsQueue_1.BatchQueue(batchSize);
+        this._flushCoordinator = new FlushCoordinator_1.FlushCoordinator(this._batchQueue, this._pendingEvents, () => this.appendAndResetNonExposedChecks(), this._sdkKey, this._network, this._emitter, this._logEventUrlConfig, this._options, this._loggingEnabled, this._errorBoundary);
+        if (this._pendingCompressionMode) {
+            this._flushCoordinator.setLogEventCompressionMode(this._pendingCompressionMode);
+            this._pendingCompressionMode = null;
         }
+        return this._flushCoordinator;
+    }
+    _storeEventToStorage(event) {
         const storageKey = this._getStorageKey();
         try {
-            const savedEvents = this._getFailedLogsFromStorage(storageKey);
-            (0, StorageProvider_1._setObjectInStorage)(storageKey, [...savedEvents, ...events]);
+            let existingEvents = this._getEventsFromStorage(storageKey);
+            existingEvents.push(event);
+            if (existingEvents.length > EventRetryConstants_1.EventRetryConstants.MAX_LOCAL_STORAGE) {
+                existingEvents = existingEvents.slice(-EventRetryConstants_1.EventRetryConstants.MAX_LOCAL_STORAGE);
+            }
+            (0, StorageProvider_1._setObjectInStorage)(storageKey, existingEvents);
         }
-        catch (_a) {
-            Log_1.Log.warn('Unable to save failed logs to storage');
+        catch (error) {
+            Log_1.Log.warn('Unable to save events to storage');
         }
     }
-    _getFailedLogsFromStorage(storageKey) {
-        let savedEvents = [];
+    _getEventsFromStorage(storageKey) {
         try {
-            const retrieved = (0, StorageProvider_1._getObjectFromStorage)(storageKey);
-            if (Array.isArray(retrieved)) {
-                savedEvents = retrieved;
+            const events = (0, StorageProvider_1._getObjectFromStorage)(storageKey);
+            if (Array.isArray(events)) {
+                return events;
             }
-            return savedEvents;
+            return [];
         }
         catch (_a) {
             return [];
         }
     }
-    _retryFailedLogs() {
+    _loadStoredEvents() {
         const storageKey = this._getStorageKey();
-        (() => __awaiter(this, void 0, void 0, function* () {
-            if (!StorageProvider_1.Storage.isReady()) {
-                yield StorageProvider_1.Storage.isReadyResolver();
-            }
-            const events = (0, StorageProvider_1._getObjectFromStorage)(storageKey);
-            if (!events) {
-                return;
-            }
+        const events = this._getEventsFromStorage(storageKey);
+        if (events.length > 0) {
             StorageProvider_1.Storage.removeItem(storageKey);
-            yield this._sendEvents(events);
-        }))().catch(() => {
-            Log_1.Log.warn('Failed to flush stored logs');
-        });
-    }
-    _getStorageKey() {
-        return `statsig.failed_logs.${(0, Hashing_1._DJB2)(this._sdkKey)}`;
+        }
+        return events;
     }
-    _normalizeAndAppendEvent(event) {
+    _normalizeEvent(event) {
         if (event.user) {
             event.user = Object.assign({}, event.user);
             delete event.user.privateAttributes;
@@ -307,45 +279,7 @@ class EventLogger {
         if (currentPage) {
             extras.statsigMetadata = { currentPage };
         }
-        const final = Object.assign(Object.assign({}, event), extras);
-        Log_1.Log.debug('Enqueued Event:', final);
-        this._queue.push(final);
-    }
-    _appendAndResetNonExposedChecks() {
-        if (Object.keys(this._nonExposedChecks).length === 0) {
-            return;
-        }
-        this._normalizeAndAppendEvent({
-            eventName: 'statsig::non_exposed_checks',
-            user: null,
-            time: Date.now(),
-            metadata: {
-                checks: Object.assign({}, this._nonExposedChecks),
-            },
-        });
-        this._nonExposedChecks = {};
-    }
-    _getCurrentPageUrl() {
-        var _a;
-        if (((_a = this._options) === null || _a === void 0 ? void 0 : _a.includeCurrentPageUrlWithEvents) === false) {
-            return;
-        }
-        return (0, SafeJs_1._getCurrentPageUrlSafe)();
-    }
-    _startBackgroundFlushInterval() {
-        var _a, _b;
-        const flushInterval = (_b = (_a = this._options) === null || _a === void 0 ? void 0 : _a.loggingIntervalMs) !== null && _b !== void 0 ? _b : DEFAULT_FLUSH_INTERVAL_MS;
-        const intervalId = setInterval(() => {
-            const logger = EVENT_LOGGER_MAP[this._sdkKey];
-            if (!logger || logger._flushIntervalId !== intervalId) {
-                clearInterval(intervalId);
-            }
-            else {
-                EventLogger._safeFlushAndForget(this._sdkKey);
-                SessionID_1.StatsigSession.checkForIdleSession(this._sdkKey);
-            }
-        }, flushInterval);
-        this._flushIntervalId = intervalId;
+        return Object.assign(Object.assign({}, event), extras);
     }
 }
 exports.EventLogger = EventLogger;

package/src/EventRetryConstants.d.ts

@@ -1,7 +1,9 @@
 export declare const EventRetryConstants: {
     readonly MAX_RETRY_ATTEMPTS: 5;
     readonly DEFAULT_BATCH_SIZE: 100;
-    readonly MAX_PENDING_BATCHES: 10;
+    readonly MAX_PENDING_BATCHES: 30;
     readonly TICK_INTERVAL_MS: 1000;
+    readonly QUICK_FLUSH_WINDOW_MS: 200;
+    readonly MAX_LOCAL_STORAGE: 500;
     readonly MAX_QUEUED_EVENTS: number;
 };

package/src/EventRetryConstants.js

@@ -4,8 +4,10 @@ exports.EventRetryConstants = void 0;
 exports.EventRetryConstants = {
     MAX_RETRY_ATTEMPTS: 5,
     DEFAULT_BATCH_SIZE: 100,
-    MAX_PENDING_BATCHES: 10,
+    MAX_PENDING_BATCHES: 30,
     TICK_INTERVAL_MS: 1000,
+    QUICK_FLUSH_WINDOW_MS: 200,
+    MAX_LOCAL_STORAGE: 500,
     get MAX_QUEUED_EVENTS() {
         return this.DEFAULT_BATCH_SIZE * this.MAX_PENDING_BATCHES;
     },