@statsig/client-core 3.31.1-beta.3 → 3.31.2-beta.1

package/package.json

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

package/src/ErrorBoundary.d.ts

@@ -10,8 +10,6 @@ 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): void;
     getLastSeenErrorAndReset(): Error | null;
     attachErrorIfNoneExists(error: unknown): void;
     private _capture;

package/src/ErrorBoundary.js

@@ -44,25 +44,6 @@ class ErrorBoundary {
     logError(tag, error) {
         this._onError(tag, error);
     }
-    logDroppedEvents(count, reason, metadata) {
-        const extra = {
-            eventCount: String(count),
-        };
-        if (metadata) {
-            Object.entries(metadata).forEach(([key, value]) => {
-                extra[key] = String(value);
-            });
-        }
-        this._onError(`statsig::log_event_dropped_event_count`, new Error(reason), true, extra);
-    }
-    logEventRequestFailure(count, reason, flushType, statusCode) {
-        const extra = {
-            eventCount: String(count),
-            flushType: flushType,
-            statusCode: String(statusCode),
-        };
-        this._onError(`statsig::log_event_failed`, new Error(reason), true, extra);
-    }
     getLastSeenErrorAndReset() {
         const tempError = this._lastSeenError;
         this._lastSeenError = undefined;
@@ -87,7 +68,7 @@ class ErrorBoundary {
             return null;
         }
     }
-    _onError(tag, error, bypassDedupe = false, extra) {
+    _onError(tag, error) {
         try {
             Log_1.Log.warn(`Caught error in ${tag}`, { error });
             const impl = () => __awaiter(this, void 0, void 0, function* () {
@@ -97,7 +78,7 @@ class ErrorBoundary {
                 const name = isError ? unwrapped.name : 'No Name';
                 const resolvedError = _resolveError(unwrapped);
                 this._lastSeenError = resolvedError;
-                if (!bypassDedupe && this._seen.has(name)) {
+                if (this._seen.has(name)) {
                     return;
                 }
                 this._seen.add(name);
@@ -112,8 +93,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,
-                    extra, statsigOptions: _getStatsigOptionLoggingCopy(this._options) }, Object.assign(Object.assign({}, statsigMetadata), { sdkType }));
+                const body = Object.assign({ tag, exception: name, info, statsigOptions: _getStatsigOptionLoggingCopy(this._options) }, Object.assign(Object.assign({}, statsigMetadata), { sdkType }));
                 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,4 +1,3 @@
-import { ErrorBoundary } from './ErrorBoundary';
 import { NetworkCore } from './NetworkCore';
 import { StatsigClientEmitEventFunc } from './StatsigClientBase';
 import { StatsigEventInternal } from './StatsigEvent';
@@ -8,18 +7,18 @@ export declare class EventLogger {
     private _emitter;
     private _network;
     private _options;
-    private _errorBoundary;
-    private _pendingEvents;
-    private _batchQueue;
-    private _flushCoordinator;
+    private _queue;
+    private _flushIntervalId;
     private _lastExposureTimeMap;
     private _nonExposedChecks;
+    private _maxQueueSize;
+    private _hasRunQuickFlush;
+    private _creationTime;
     private _loggingEnabled;
     private _logEventUrlConfig;
-    private _isShuttingDown;
-    private _storageKey;
     private static _safeFlushAndForget;
-    constructor(_sdkKey: string, _emitter: StatsigClientEmitEventFunc, _network: NetworkCore, _options: StatsigOptionsCommon<NetworkConfigCommon> | null, _errorBoundary: ErrorBoundary);
+    private static _safeRetryFailedLogs;
+    constructor(_sdkKey: string, _emitter: StatsigClientEmitEventFunc, _network: NetworkCore, _options: StatsigOptionsCommon<NetworkConfigCommon> | null);
     setLogEventCompressionMode(mode: LogEventCompressionMode): void;
     setLoggingEnabled(loggingEnabled: LoggingEnabledOption): void;
     enqueue(event: StatsigEventInternal): void;
@@ -28,12 +27,22 @@ export declare class EventLogger {
     start(): void;
     stop(): Promise<void>;
     flush(): Promise<void>;
-    appendAndResetNonExposedChecks(): void;
+    /**
+     * We 'Quick Flush' following the very first event enqueued
+     * within the quick flush window
+     */
+    private _quickFlushIfNeeded;
     private _shouldLogEvent;
-    private _getCurrentPageUrl;
+    private _sendEvents;
+    private _sendEventsViaPost;
+    private _sendEventsViaBeacon;
+    private _getRequestData;
+    private _saveFailedLogsToStorage;
+    private _getFailedLogsFromStorage;
+    private _retryFailedLogs;
     private _getStorageKey;
-    private _storeEventToStorage;
-    private _getEventsFromStorage;
-    private _loadStoredEvents;
-    private _normalizeEvent;
+    private _normalizeAndAppendEvent;
+    private _appendAndResetNonExposedChecks;
+    private _getCurrentPageUrl;
+    private _startBackgroundFlushInterval;
 }

package/src/EventLogger.js

@@ -10,22 +10,23 @@ 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) {
@@ -34,17 +35,21 @@ class EventLogger {
             // noop
         });
     }
-    constructor(_sdkKey, _emitter, _network, _options, _errorBoundary) {
+    static _safeRetryFailedLogs(sdkKey) {
+        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._errorBoundary = _errorBoundary;
+        this._queue = [];
         this._lastExposureTimeMap = {};
         this._nonExposedChecks = {};
-        this._isShuttingDown = false;
-        this._storageKey = null;
+        this._hasRunQuickFlush = false;
+        this._creationTime = Date.now();
         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
@@ -52,45 +57,34 @@ 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);
-        const batchSize = (_b = _options === null || _options === void 0 ? void 0 : _options.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);
     }
     setLogEventCompressionMode(mode) {
-        this._flushCoordinator.setLogEventCompressionMode(mode);
+        this._network.setLogEventCompressionMode(mode);
     }
     setLoggingEnabled(loggingEnabled) {
-        const wasDisabled = this._loggingEnabled === 'disabled';
-        const isNowEnabled = loggingEnabled !== 'disabled';
-        this._loggingEnabled = loggingEnabled;
-        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._flushCoordinator.addEvent(event);
-                });
-                this.flush().catch((error) => {
-                    Log_1.Log.warn('Failed to flush events after enabling logging:', error);
-                });
+        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);
             }
+            StorageProvider_1.Storage.removeItem(storageKey);
         }
+        this._loggingEnabled = loggingEnabled;
     }
     enqueue(event) {
         if (!this._shouldLogEvent(event)) {
             return;
         }
-        const normalizedEvent = this._normalizeEvent(event);
-        if (this._loggingEnabled === 'disabled') {
-            this._storeEventToStorage(normalizedEvent);
-            return;
+        this._normalizeAndAppendEvent(event);
+        this._quickFlushIfNeeded();
+        if (this._queue.length > this._maxQueueSize) {
+            EventLogger._safeFlushAndForget(this._sdkKey);
         }
-        this._flushCoordinator.addEvent(normalizedEvent);
-        this._flushCoordinator.checkQuickFlush();
     }
     incrementNonExposureCount(name) {
         var _a;
@@ -117,42 +111,47 @@ class EventLogger {
                     EventLogger._safeFlushAndForget(this._sdkKey);
                 }
                 else if (visibility === 'foreground') {
-                    this._flushCoordinator.startScheduledFlushCycle();
+                    EventLogger._safeRetryFailedLogs(this._sdkKey);
                 }
             });
         }
-        this._flushCoordinator.loadAndRetryShutdownFailedEvents().catch((error) => {
-            Log_1.Log.warn('Failed to load failed shutdown events:', error);
-        });
-        this._flushCoordinator.startScheduledFlushCycle();
+        this._retryFailedLogs();
+        this._startBackgroundFlushInterval();
     }
     stop() {
         return __awaiter(this, void 0, void 0, function* () {
-            this._isShuttingDown = true;
-            yield this._flushCoordinator.processShutdown();
+            if (this._flushIntervalId) {
+                clearInterval(this._flushIntervalId);
+                this._flushIntervalId = null;
+            }
             delete EVENT_LOGGER_MAP[this._sdkKey];
+            yield this.flush();
         });
     }
     flush() {
         return __awaiter(this, void 0, void 0, function* () {
-            return this._flushCoordinator.processManualFlush();
+            this._appendAndResetNonExposedChecks();
+            if (this._queue.length === 0) {
+                return;
+            }
+            const events = this._queue;
+            this._queue = [];
+            yield this._sendEvents(events);
         });
     }
-    appendAndResetNonExposedChecks() {
-        if (Object.keys(this._nonExposedChecks).length === 0) {
+    /**
+     * We 'Quick Flush' following the very first event enqueued
+     * within the quick flush window
+     */
+    _quickFlushIfNeeded() {
+        if (this._hasRunQuickFlush) {
             return;
         }
-        const checks = Object.assign({}, this._nonExposedChecks);
-        this._nonExposedChecks = {};
-        const event = this._normalizeEvent({
-            eventName: 'statsig::non_exposed_checks',
-            user: null,
-            time: Date.now(),
-            metadata: {
-                checks,
-            },
-        });
-        this._flushCoordinator.addEvent(event);
+        this._hasRunQuickFlush = true;
+        if (Date.now() - this._creationTime > QUICK_FLUSH_WINDOW_MS) {
+            return;
+        }
+        setTimeout(() => EventLogger._safeFlushAndForget(this._sdkKey), QUICK_FLUSH_WINDOW_MS);
     }
     _shouldLogEvent(event) {
         var _a;
@@ -187,54 +186,118 @@ class EventLogger {
         this._lastExposureTimeMap[key] = now;
         return true;
     }
-    _getCurrentPageUrl() {
-        var _a;
-        if (((_a = this._options) === null || _a === void 0 ? void 0 : _a.includeCurrentPageUrlWithEvents) === false) {
-            return;
-        }
-        return (0, SafeJs_1._getCurrentPageUrlSafe)();
+    _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;
+            }
+        });
     }
-    _getStorageKey() {
-        if (!this._storageKey) {
-            this._storageKey = `statsig.pending_events.${(0, Hashing_1._DJB2)(this._sdkKey)}`;
-        }
-        return this._storageKey;
+    _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)),
+        };
+    }
+    _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',
+        };
     }
-    _storeEventToStorage(event) {
+    _saveFailedLogsToStorage(events) {
+        while (events.length > MAX_FAILED_LOGS) {
+            events.shift();
+        }
         const storageKey = this._getStorageKey();
         try {
-            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);
+            const savedEvents = this._getFailedLogsFromStorage(storageKey);
+            (0, StorageProvider_1._setObjectInStorage)(storageKey, [...savedEvents, ...events]);
         }
-        catch (error) {
-            Log_1.Log.warn('Unable to save events to storage');
+        catch (_a) {
+            Log_1.Log.warn('Unable to save failed logs to storage');
         }
     }
-    _getEventsFromStorage(storageKey) {
+    _getFailedLogsFromStorage(storageKey) {
+        let savedEvents = [];
         try {
-            const events = (0, StorageProvider_1._getObjectFromStorage)(storageKey);
-            if (Array.isArray(events)) {
-                return events;
+            const retrieved = (0, StorageProvider_1._getObjectFromStorage)(storageKey);
+            if (Array.isArray(retrieved)) {
+                savedEvents = retrieved;
             }
-            return [];
+            return savedEvents;
         }
         catch (_a) {
             return [];
         }
     }
-    _loadStoredEvents() {
+    _retryFailedLogs() {
         const storageKey = this._getStorageKey();
-        const events = this._getEventsFromStorage(storageKey);
-        if (events.length > 0) {
+        (() => __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;
+            }
             StorageProvider_1.Storage.removeItem(storageKey);
-        }
-        return events;
+            yield this._sendEvents(events);
+        }))().catch(() => {
+            Log_1.Log.warn('Failed to flush stored logs');
+        });
     }
-    _normalizeEvent(event) {
+    _getStorageKey() {
+        return `statsig.failed_logs.${(0, Hashing_1._DJB2)(this._sdkKey)}`;
+    }
+    _normalizeAndAppendEvent(event) {
         if (event.user) {
             event.user = Object.assign({}, event.user);
             delete event.user.privateAttributes;
@@ -244,7 +307,45 @@ class EventLogger {
         if (currentPage) {
             extras.statsigMetadata = { currentPage };
         }
-        return Object.assign(Object.assign({}, event), extras);
+        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;
     }
 }
 exports.EventLogger = EventLogger;

package/src/EventRetryConstants.d.ts

@@ -1,9 +1,7 @@
 export declare const EventRetryConstants: {
     readonly MAX_RETRY_ATTEMPTS: 5;
     readonly DEFAULT_BATCH_SIZE: 100;
-    readonly MAX_PENDING_BATCHES: 30;
+    readonly MAX_PENDING_BATCHES: 10;
     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,10 +4,8 @@ exports.EventRetryConstants = void 0;
 exports.EventRetryConstants = {
     MAX_RETRY_ATTEMPTS: 5,
     DEFAULT_BATCH_SIZE: 100,
-    MAX_PENDING_BATCHES: 30,
+    MAX_PENDING_BATCHES: 10,
     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;
     },

package/src/NetworkCore.d.ts

@@ -5,7 +5,6 @@ import { StatsigClientEmitEventFunc } from './StatsigClientBase';
 import { AnyStatsigOptions, LogEventCompressionMode } from './StatsigOptionsCommon';
 import { Flatten } from './TypingUtils';
 import { UrlConfiguration } from './UrlConfiguration';
-export declare const RETRYABLE_CODES: Set<number>;
 type RequestArgs = {
     sdkKey: string;
     urlConfig: UrlConfiguration;

package/src/NetworkCore.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NetworkCore = exports.RETRYABLE_CODES = void 0;
+exports.NetworkCore = void 0;
 require("./$_StatsigGlobal");
 const __StatsigGlobal_1 = require("./$_StatsigGlobal");
 const Diagnostics_1 = require("./Diagnostics");
@@ -31,9 +31,7 @@ const BACKOFF_MAX_MS = 30000;
 const RATE_LIMIT_WINDOW_MS = 1000;
 const RATE_LIMIT_MAX_REQ_COUNT = 50;
 const LEAK_RATE = RATE_LIMIT_MAX_REQ_COUNT / RATE_LIMIT_WINDOW_MS;
-exports.RETRYABLE_CODES = new Set([
-    408, 500, 502, 503, 504, 522, 524, 599,
-]);
+const RETRYABLE_CODES = new Set([408, 500, 502, 503, 504, 522, 524, 599]);
 class NetworkCore {
     constructor(options, _emitter) {
         this._emitter = _emitter;
@@ -163,7 +161,7 @@ class NetworkCore {
                 }
                 if (!retries ||
                     currentAttempt > retries ||
-                    !exports.RETRYABLE_CODES.has((_b = response === null || response === void 0 ? void 0 : response.status) !== null && _b !== void 0 ? _b : 500)) {
+                    !RETRYABLE_CODES.has((_b = response === null || response === void 0 ? void 0 : response.status) !== null && _b !== void 0 ? _b : 500)) {
                     (_c = this._emitter) === null || _c === void 0 ? void 0 : _c.call(this, {
                         name: 'error',
                         error,

package/src/StatsigClientBase.js

@@ -41,8 +41,8 @@ class StatsigClientBase {
         this._options = options !== null && options !== void 0 ? options : {};
         this._memoCache = {};
         this.overrideAdapter = (_a = options === null || options === void 0 ? void 0 : options.overrideAdapter) !== null && _a !== void 0 ? _a : null;
+        this._logger = new EventLogger_1.EventLogger(sdkKey, emitter, network, options);
         this._errorBoundary = new ErrorBoundary_1.ErrorBoundary(sdkKey, options, emitter);
-        this._logger = new EventLogger_1.EventLogger(sdkKey, emitter, network, options, this._errorBoundary);
         this._errorBoundary.wrap(this);
         this._errorBoundary.wrap(adapter);
         this._errorBoundary.wrap(this._logger);

package/src/StatsigMetadata.d.ts

@@ -1,4 +1,4 @@
-export declare const SDK_VERSION = "3.31.1-beta.3";
+export declare const SDK_VERSION = "3.31.2-beta.1";
 export type StatsigMetadata = {
     readonly [key: string]: string | undefined | null;
     readonly appVersion?: string;

package/src/StatsigMetadata.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StatsigMetadataProvider = exports.SDK_VERSION = void 0;
-exports.SDK_VERSION = '3.31.1-beta.3';
+exports.SDK_VERSION = '3.31.2-beta.1';
 let metadata = {
     sdkVersion: exports.SDK_VERSION,
     sdkType: 'js-mono', // js-mono is overwritten by Precomp and OnDevice clients

package/src/BatchedEventsQueue.d.ts

@@ -1,14 +0,0 @@
-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 | null;
-    takeAllBatches(): EventBatch[];
-    createBatches(events: StatsigEventInternal[]): number;
-    private _enqueueBatch;
-}

package/src/BatchedEventsQueue.js

@@ -1,51 +0,0 @@
-"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() {
-        var _a;
-        return (_a = this._batches.shift()) !== null && _a !== void 0 ? _a : null;
-    }
-    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/EventSender.d.ts

@@ -1,23 +0,0 @@
-import { EventBatch } from './EventBatch';
-import { NetworkCore } from './NetworkCore';
-import { StatsigClientEmitEventFunc } from './StatsigClientBase';
-import { LogEventCompressionMode, LoggingEnabledOption, NetworkConfigCommon, StatsigOptionsCommon } from './StatsigOptionsCommon';
-import { UrlConfiguration } from './UrlConfiguration';
-export declare class EventSender {
-    private _network;
-    private _sdkKey;
-    private _options;
-    private _logEventUrlConfig;
-    private _emitter;
-    private _loggingEnabled;
-    constructor(sdkKey: string, network: NetworkCore, emitter: StatsigClientEmitEventFunc, logEventUrlConfig: UrlConfiguration, options: StatsigOptionsCommon<NetworkConfigCommon> | null, loggingEnabled: LoggingEnabledOption);
-    setLogEventCompressionMode(mode: LogEventCompressionMode): void;
-    setLoggingEnabled(enabled: LoggingEnabledOption): void;
-    sendBatch(batch: EventBatch): Promise<{
-        success: boolean;
-        statusCode: number;
-    }>;
-    private _sendEventsViaPost;
-    private _sendEventsViaBeacon;
-    private _getRequestData;
-}

package/src/EventSender.js

@@ -1,96 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventSender = void 0;
-const Log_1 = require("./Log");
-const NetworkConfig_1 = require("./NetworkConfig");
-const VisibilityObserving_1 = require("./VisibilityObserving");
-class EventSender {
-    constructor(sdkKey, network, emitter, logEventUrlConfig, options, loggingEnabled) {
-        this._sdkKey = sdkKey;
-        this._network = network;
-        this._emitter = emitter;
-        this._options = options;
-        this._logEventUrlConfig = logEventUrlConfig;
-        this._loggingEnabled = loggingEnabled;
-    }
-    setLogEventCompressionMode(mode) {
-        this._network.setLogEventCompressionMode(mode);
-    }
-    setLoggingEnabled(enabled) {
-        this._loggingEnabled = enabled;
-    }
-    sendBatch(batch) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            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: batch.events,
-                });
-                const response = shouldUseBeacon
-                    ? this._sendEventsViaBeacon(batch)
-                    : yield this._sendEventsViaPost(batch);
-                if (response.success) {
-                    this._emitter({
-                        name: 'logs_flushed',
-                        events: batch.events,
-                    });
-                    return response;
-                }
-                return { success: false, statusCode: -1 };
-            }
-            catch (error) {
-                Log_1.Log.warn('Failed to send batch:', error);
-                return { success: false, statusCode: -1 };
-            }
-        });
-    }
-    _sendEventsViaPost(batch) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const result = yield this._network.post(this._getRequestData(batch));
-            const code = (_a = result === null || result === void 0 ? void 0 : result.code) !== null && _a !== void 0 ? _a : -1;
-            return { success: code >= 200 && code < 300, statusCode: code };
-        });
-    }
-    _sendEventsViaBeacon(batch) {
-        const success = this._network.beacon(this._getRequestData(batch));
-        return {
-            success,
-            statusCode: success ? 200 : -1,
-        };
-    }
-    _getRequestData(batch) {
-        return {
-            sdkKey: this._sdkKey,
-            data: {
-                events: batch.events,
-            },
-            urlConfig: this._logEventUrlConfig,
-            retries: 3,
-            isCompressable: true,
-            params: {
-                [NetworkConfig_1.NetworkParam.EventCount]: String(batch.events.length),
-            },
-            headers: {
-                'statsig-event-count': String(batch.events.length),
-                'statsig-retry-count': String(batch.attempts),
-            },
-            credentials: 'same-origin',
-        };
-    }
-}
-exports.EventSender = EventSender;

package/src/FlushCoordinator.d.ts

@@ -1,50 +0,0 @@
-import { BatchQueue } from './BatchedEventsQueue';
-import { ErrorBoundary } from './ErrorBoundary';
-import { NetworkCore } from './NetworkCore';
-import { PendingEvents } from './PendingEvents';
-import { StatsigClientEmitEventFunc } from './StatsigClientBase';
-import { StatsigEventInternal } from './StatsigEvent';
-import { LogEventCompressionMode, LoggingEnabledOption, NetworkConfigCommon, StatsigOptionsCommon } from './StatsigOptionsCommon';
-import { UrlConfiguration } from './UrlConfiguration';
-type PrepareFlushCallBack = () => void;
-export declare class FlushCoordinator {
-    private _flushInterval;
-    private _batchQueue;
-    private _pendingEvents;
-    private _eventSender;
-    private _onPrepareFlush;
-    private _errorBoundary;
-    private _cooldownTimer;
-    private _maxIntervalTimer;
-    private _hasRunQuickFlush;
-    private _currentFlushPromise;
-    private _creationTime;
-    private _sdkKey;
-    private _storageKey;
-    constructor(batchQueue: BatchQueue, pendingEvents: PendingEvents, onPrepareFlush: PrepareFlushCallBack, sdkKey: string, network: NetworkCore, emitter: StatsigClientEmitEventFunc, logEventUrlConfig: UrlConfiguration, options: StatsigOptionsCommon<NetworkConfigCommon> | null, loggingEnabled: LoggingEnabledOption, errorBoundary: ErrorBoundary);
-    setLoggingEnabled(loggingEnabled: LoggingEnabledOption): void;
-    setLogEventCompressionMode(mode: LogEventCompressionMode): void;
-    startScheduledFlushCycle(): void;
-    stopScheduledFlushCycle(): void;
-    addEvent(event: StatsigEventInternal): void;
-    processManualFlush(): Promise<void>;
-    processShutdown(): Promise<void>;
-    private _executeFlush;
-    checkQuickFlush(): void;
-    private _attemptScheduledFlush;
-    processLimitFlush(): void;
-    private _processLimitFlushInternal;
-    private _scheduleNextFlush;
-    private _clearAllTimers;
-    private _processNextBatch;
-    private _processOneBatch;
-    private _prepareQueueForFlush;
-    containsAtLeastOneFullBatch(): boolean;
-    convertPendingEventsToBatches(): number;
-    private _handleFailure;
-    loadAndRetryShutdownFailedEvents(): Promise<void>;
-    private _getStorageKey;
-    private _saveShutdownFailedEventsToStorage;
-    private _getShutdownFailedEventsFromStorage;
-}
-export {};

package/src/FlushCoordinator.js

@@ -1,338 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlushCoordinator = void 0;
-const EventRetryConstants_1 = require("./EventRetryConstants");
-const EventSender_1 = require("./EventSender");
-const FlushInterval_1 = require("./FlushInterval");
-const FlushTypes_1 = require("./FlushTypes");
-const Hashing_1 = require("./Hashing");
-const Log_1 = require("./Log");
-const NetworkCore_1 = require("./NetworkCore");
-const SessionID_1 = require("./SessionID");
-const StorageProvider_1 = require("./StorageProvider");
-class FlushCoordinator {
-    constructor(batchQueue, pendingEvents, onPrepareFlush, 
-    // For Event Sender
-    sdkKey, network, emitter, logEventUrlConfig, options, loggingEnabled, errorBoundary) {
-        this._cooldownTimer = null;
-        this._maxIntervalTimer = null;
-        this._hasRunQuickFlush = false;
-        this._currentFlushPromise = null;
-        this._creationTime = Date.now();
-        this._storageKey = null;
-        this._flushInterval = new FlushInterval_1.FlushInterval();
-        this._batchQueue = batchQueue;
-        this._pendingEvents = pendingEvents;
-        this._onPrepareFlush = onPrepareFlush;
-        this._errorBoundary = errorBoundary;
-        this._sdkKey = sdkKey;
-        this._eventSender = new EventSender_1.EventSender(sdkKey, network, emitter, logEventUrlConfig, options, loggingEnabled);
-    }
-    setLoggingEnabled(loggingEnabled) {
-        this._eventSender.setLoggingEnabled(loggingEnabled);
-    }
-    setLogEventCompressionMode(mode) {
-        this._eventSender.setLogEventCompressionMode(mode);
-    }
-    startScheduledFlushCycle() {
-        this._scheduleNextFlush();
-    }
-    stopScheduledFlushCycle() {
-        this._clearAllTimers();
-    }
-    addEvent(event) {
-        this._pendingEvents.addToPendingEventsQueue(event);
-        if (this._currentFlushPromise) {
-            return;
-        }
-        if (this._pendingEvents.hasEventsForFullBatch()) {
-            this.processLimitFlush();
-        }
-    }
-    processManualFlush() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._currentFlushPromise) {
-                yield this._currentFlushPromise;
-            }
-            this._currentFlushPromise = this._executeFlush(FlushTypes_1.FlushType.Manual).finally(() => {
-                this._currentFlushPromise = null;
-                this._scheduleNextFlush();
-            });
-            return this._currentFlushPromise;
-        });
-    }
-    processShutdown() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._currentFlushPromise) {
-                yield this._currentFlushPromise;
-            }
-            this._currentFlushPromise = this._executeFlush(FlushTypes_1.FlushType.Shutdown)
-                .catch((error) => {
-                Log_1.Log.error(`Error during shutdown flush: ${error}`);
-            })
-                .finally(() => {
-                this._currentFlushPromise = null;
-            });
-            return this._currentFlushPromise;
-        });
-    }
-    _executeFlush(flushType) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._clearAllTimers();
-            try {
-                this._prepareQueueForFlush(flushType);
-                const batches = this._batchQueue.takeAllBatches();
-                if (batches.length === 0) {
-                    return;
-                }
-                yield Promise.all(batches.map((batch) => this._processOneBatch(batch, flushType)));
-            }
-            finally {
-                this._scheduleNextFlush();
-            }
-        });
-    }
-    checkQuickFlush() {
-        if (this._hasRunQuickFlush) {
-            return;
-        }
-        if (Date.now() - this._creationTime >
-            EventRetryConstants_1.EventRetryConstants.QUICK_FLUSH_WINDOW_MS) {
-            return;
-        }
-        this._hasRunQuickFlush = true;
-        setTimeout(() => {
-            this.processManualFlush().catch((error) => {
-                Log_1.Log.warn('Quick flush failed:', error);
-            });
-        }, EventRetryConstants_1.EventRetryConstants.QUICK_FLUSH_WINDOW_MS);
-    }
-    _attemptScheduledFlush() {
-        if (this._currentFlushPromise) {
-            this._scheduleNextFlush();
-            return;
-        }
-        const shouldFlushBySize = this.containsAtLeastOneFullBatch();
-        const shouldFlushByTime = this._flushInterval.hasReachedMaxInterval();
-        if (!shouldFlushBySize && !shouldFlushByTime) {
-            this._scheduleNextFlush();
-            return;
-        }
-        this._flushInterval.markFlushAttempt();
-        let flushType;
-        if (shouldFlushBySize) {
-            flushType = FlushTypes_1.FlushType.ScheduledFullBatch;
-        }
-        else {
-            flushType = FlushTypes_1.FlushType.ScheduledMaxTime;
-        }
-        this._currentFlushPromise = this._processNextBatch(flushType)
-            .then(() => {
-            //This discards boolean result. Main goal here is to track completion
-        })
-            .catch((error) => {
-            Log_1.Log.error('Error during scheduled flush:', error);
-        })
-            .finally(() => {
-            this._currentFlushPromise = null;
-            this._scheduleNextFlush();
-        });
-    }
-    processLimitFlush() {
-        if (!this._flushInterval.hasCompletelyRecoveredFromBackoff()) {
-            return;
-        }
-        if (this._currentFlushPromise) {
-            return;
-        }
-        this._currentFlushPromise = this._processLimitFlushInternal()
-            .catch((error) => {
-            Log_1.Log.error(`Error during limit flush`, error);
-        })
-            .finally(() => {
-            this._currentFlushPromise = null;
-            this._scheduleNextFlush();
-        });
-    }
-    _processLimitFlushInternal() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const success = yield this._processNextBatch(FlushTypes_1.FlushType.Limit);
-            if (!success) {
-                return;
-            }
-            while (this._flushInterval.hasCompletelyRecoveredFromBackoff() &&
-                this.containsAtLeastOneFullBatch()) {
-                const success = yield this._processNextBatch(FlushTypes_1.FlushType.Limit);
-                if (!success) {
-                    break;
-                }
-            }
-        });
-    }
-    _scheduleNextFlush() {
-        this._clearAllTimers();
-        const cooldownDelay = Math.max(0, this._flushInterval.getTimeUntilNextFlush());
-        this._cooldownTimer = setTimeout(() => {
-            this._cooldownTimer = null;
-            SessionID_1.StatsigSession.checkForIdleSession(this._sdkKey);
-            this._attemptScheduledFlush();
-        }, cooldownDelay);
-        const maxIntervalDelay = Math.max(0, this._flushInterval.getTimeTillMaxInterval());
-        this._maxIntervalTimer = setTimeout(() => {
-            this._maxIntervalTimer = null;
-            SessionID_1.StatsigSession.checkForIdleSession(this._sdkKey);
-            this._attemptScheduledFlush();
-        }, maxIntervalDelay);
-    }
-    _clearAllTimers() {
-        if (this._cooldownTimer !== null) {
-            clearTimeout(this._cooldownTimer);
-            this._cooldownTimer = null;
-        }
-        if (this._maxIntervalTimer !== null) {
-            clearTimeout(this._maxIntervalTimer);
-            this._maxIntervalTimer = null;
-        }
-    }
-    _processNextBatch(flushType) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._prepareQueueForFlush(flushType);
-            const batch = this._batchQueue.takeNextBatch();
-            if (!batch) {
-                return false;
-            }
-            return this._processOneBatch(batch, flushType);
-        });
-    }
-    _processOneBatch(batch, flushType) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = yield this._eventSender.sendBatch(batch);
-            if (result.success) {
-                this._flushInterval.adjustForSuccess();
-                return true;
-            }
-            this._flushInterval.adjustForFailure();
-            this._handleFailure(batch, flushType, result.statusCode);
-            return false;
-        });
-    }
-    _prepareQueueForFlush(flushType) {
-        this._onPrepareFlush();
-        const droppedCount = this.convertPendingEventsToBatches();
-        if (droppedCount > 0) {
-            Log_1.Log.warn(`Dropped ${droppedCount} events`);
-            this._errorBoundary.logDroppedEvents(droppedCount, `Batch queue limit reached`, {
-                loggingInterval: this._flushInterval.getCurrentIntervalMs(),
-                batchSize: this._batchQueue.batchSize(),
-                maxPendingBatches: EventRetryConstants_1.EventRetryConstants.MAX_PENDING_BATCHES,
-                flushType: flushType,
-            });
-        }
-    }
-    containsAtLeastOneFullBatch() {
-        return (this._pendingEvents.hasEventsForFullBatch() ||
-            this._batchQueue.hasFullBatch());
-    }
-    convertPendingEventsToBatches() {
-        if (this._pendingEvents.isEmpty()) {
-            return 0;
-        }
-        const allEvents = this._pendingEvents.takeAll();
-        return this._batchQueue.createBatches(allEvents);
-    }
-    _handleFailure(batch, flushType, statusCode) {
-        if (flushType === FlushTypes_1.FlushType.Shutdown) {
-            Log_1.Log.warn(`${flushType} flush failed during shutdown. ` +
-                `${batch.events.length} event(s) will be saved to storage for retry in next session.`);
-            this._saveShutdownFailedEventsToStorage(batch.events);
-            this._errorBoundary.logEventRequestFailure(batch.events.length, `flush failed during shutdown - saved to storage`, flushType, statusCode);
-            return;
-        }
-        if (!NetworkCore_1.RETRYABLE_CODES.has(statusCode)) {
-            Log_1.Log.warn(`${flushType} flush failed after ${batch.attempts} attempt(s). ` +
-                `${batch.events.length} event(s) will be dropped. Non-retryable error: ${statusCode}`);
-            this._errorBoundary.logEventRequestFailure(batch.events.length, `non-retryable error`, flushType, statusCode);
-            return;
-        }
-        if (batch.attempts >= EventRetryConstants_1.EventRetryConstants.MAX_RETRY_ATTEMPTS) {
-            Log_1.Log.warn(`${flushType} flush failed after ${batch.attempts} attempt(s). ` +
-                `${batch.events.length} event(s) will be dropped.`);
-            this._errorBoundary.logEventRequestFailure(batch.events.length, `max retry attempts exceeded`, flushType, statusCode);
-            return;
-        }
-        batch.incrementAttempts();
-        const droppedCount = this._batchQueue.requeueBatch(batch);
-        if (droppedCount > 0) {
-            Log_1.Log.warn(`Failed to requeue batch : dropped ${droppedCount} events due to full queue`);
-            this._errorBoundary.logDroppedEvents(droppedCount, `Batch queue limit reached`, {
-                loggingInterval: this._flushInterval.getCurrentIntervalMs(),
-                batchSize: this._batchQueue.batchSize(),
-                maxPendingBatches: EventRetryConstants_1.EventRetryConstants.MAX_PENDING_BATCHES,
-                flushType: flushType,
-            });
-        }
-    }
-    loadAndRetryShutdownFailedEvents() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const storageKey = this._getStorageKey();
-            try {
-                const events = this._getShutdownFailedEventsFromStorage(storageKey);
-                if (events.length === 0) {
-                    return;
-                }
-                Log_1.Log.debug(`Loading ${events.length} failed shutdown event(s) from storage for retry`);
-                StorageProvider_1.Storage.removeItem(storageKey);
-                events.forEach((event) => {
-                    this.addEvent(event);
-                });
-                yield this.processManualFlush();
-            }
-            catch (error) {
-                Log_1.Log.warn('Failed to load and retry failed shutdown events:', error);
-            }
-        });
-    }
-    _getStorageKey() {
-        if (!this._storageKey) {
-            this._storageKey = `statsig.failed_shutdown_events.${(0, Hashing_1._DJB2)(this._sdkKey)}`;
-        }
-        return this._storageKey;
-    }
-    _saveShutdownFailedEventsToStorage(events) {
-        const storageKey = this._getStorageKey();
-        try {
-            const existingEvents = this._getShutdownFailedEventsFromStorage(storageKey);
-            let allEvents = [...existingEvents, ...events];
-            if (allEvents.length > EventRetryConstants_1.EventRetryConstants.MAX_LOCAL_STORAGE) {
-                allEvents = allEvents.slice(-EventRetryConstants_1.EventRetryConstants.MAX_LOCAL_STORAGE);
-            }
-            (0, StorageProvider_1._setObjectInStorage)(storageKey, allEvents);
-            Log_1.Log.debug(`Saved ${events.length} failed shutdown event(s) to storage (total stored: ${allEvents.length})`);
-        }
-        catch (error) {
-            Log_1.Log.warn('Unable to save failed shutdown events to storage:', error);
-        }
-    }
-    _getShutdownFailedEventsFromStorage(storageKey) {
-        try {
-            const events = (0, StorageProvider_1._getObjectFromStorage)(storageKey);
-            if (Array.isArray(events)) {
-                return events;
-            }
-            return [];
-        }
-        catch (_a) {
-            return [];
-        }
-    }
-}
-exports.FlushCoordinator = FlushCoordinator;

package/src/FlushInterval.d.ts

@@ -1,13 +0,0 @@
-export declare class FlushInterval {
-    private _currentIntervalMs;
-    private _lastFlushAttemptTime;
-    getCurrentIntervalMs(): number;
-    markFlushAttempt(): void;
-    getTimeSinceLastAttempt(): number;
-    hasReachedMaxInterval(): boolean;
-    getTimeTillMaxInterval(): number;
-    hasCompletelyRecoveredFromBackoff(): boolean;
-    adjustForSuccess(): void;
-    adjustForFailure(): void;
-    getTimeUntilNextFlush(): number;
-}

package/src/FlushInterval.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlushInterval = void 0;
-const MIN_FLUSH_INTERVAL_MS = 1000;
-const MAX_FLUSH_INTERVAL_MS = 60000;
-class FlushInterval {
-    constructor() {
-        this._currentIntervalMs = MIN_FLUSH_INTERVAL_MS;
-        this._lastFlushAttemptTime = Date.now();
-    }
-    getCurrentIntervalMs() {
-        return this._currentIntervalMs;
-    }
-    markFlushAttempt() {
-        this._lastFlushAttemptTime = Date.now();
-    }
-    getTimeSinceLastAttempt() {
-        return Date.now() - this._lastFlushAttemptTime;
-    }
-    hasReachedMaxInterval() {
-        return this.getTimeSinceLastAttempt() >= MAX_FLUSH_INTERVAL_MS;
-    }
-    getTimeTillMaxInterval() {
-        return MAX_FLUSH_INTERVAL_MS - this.getTimeSinceLastAttempt();
-    }
-    hasCompletelyRecoveredFromBackoff() {
-        return this._currentIntervalMs <= MIN_FLUSH_INTERVAL_MS;
-    }
-    adjustForSuccess() {
-        const current = this._currentIntervalMs;
-        if (current === MIN_FLUSH_INTERVAL_MS) {
-            return;
-        }
-        this._currentIntervalMs = Math.max(MIN_FLUSH_INTERVAL_MS, Math.floor(current / 2));
-    }
-    adjustForFailure() {
-        const current = this._currentIntervalMs;
-        this._currentIntervalMs = Math.min(MAX_FLUSH_INTERVAL_MS, current * 2);
-    }
-    getTimeUntilNextFlush() {
-        return this.getCurrentIntervalMs() - this.getTimeSinceLastAttempt();
-    }
-}
-exports.FlushInterval = FlushInterval;

package/src/FlushTypes.d.ts

@@ -1,7 +0,0 @@
-export declare enum FlushType {
-    ScheduledMaxTime = "scheduled:max_time",
-    ScheduledFullBatch = "scheduled:full_batch",
-    Limit = "limit",
-    Manual = "manual",
-    Shutdown = "shutdown"
-}

package/src/FlushTypes.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlushType = void 0;
-/* eslint-disable no-restricted-syntax */
-var FlushType;
-(function (FlushType) {
-    FlushType["ScheduledMaxTime"] = "scheduled:max_time";
-    FlushType["ScheduledFullBatch"] = "scheduled:full_batch";
-    FlushType["Limit"] = "limit";
-    FlushType["Manual"] = "manual";
-    FlushType["Shutdown"] = "shutdown";
-})(FlushType || (exports.FlushType = FlushType = {}));

package/src/PendingEvents.d.ts

@@ -1,10 +0,0 @@
-import { StatsigEventInternal } from './StatsigEvent';
-export declare class PendingEvents {
-    private _pendingEvents;
-    private _batchSize;
-    constructor(batchSize: number);
-    addToPendingEventsQueue(event: StatsigEventInternal): void;
-    hasEventsForFullBatch(): boolean;
-    takeAll(): StatsigEventInternal[];
-    isEmpty(): boolean;
-}

package/src/PendingEvents.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PendingEvents = void 0;
-const Log_1 = require("./Log");
-class PendingEvents {
-    constructor(batchSize) {
-        this._pendingEvents = [];
-        this._batchSize = batchSize;
-    }
-    addToPendingEventsQueue(event) {
-        this._pendingEvents.push(event);
-        Log_1.Log.debug('Enqueued Event:', event);
-    }
-    hasEventsForFullBatch() {
-        return this._pendingEvents.length >= this._batchSize;
-    }
-    takeAll() {
-        const events = this._pendingEvents;
-        this._pendingEvents = [];
-        return events;
-    }
-    isEmpty() {
-        return this._pendingEvents.length === 0;
-    }
-}
-exports.PendingEvents = PendingEvents;