@statsig/client-core 3.30.1 → 3.30.2-beta.1

package/src/EventSender.js

@@ -0,0 +1,96 @@
+"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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,332 @@
+"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 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._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;
+            this._attemptScheduledFlush();
+        }, cooldownDelay);
+        const maxIntervalDelay = Math.max(0, this._flushInterval.getTimeTillMaxInterval());
+        this._maxIntervalTimer = setTimeout(() => {
+            this._maxIntervalTimer = null;
+            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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,44 @@
+"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

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

package/src/FlushTypes.js

@@ -0,0 +1,12 @@
+"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/NetworkCore.d.ts

@@ -5,6 +5,7 @@ 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 = void 0;
+exports.NetworkCore = exports.RETRYABLE_CODES = void 0;
 require("./$_StatsigGlobal");
 const __StatsigGlobal_1 = require("./$_StatsigGlobal");
 const Diagnostics_1 = require("./Diagnostics");
@@ -31,7 +31,9 @@ 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;
-const RETRYABLE_CODES = new Set([408, 500, 502, 503, 504, 522, 524, 599]);
+exports.RETRYABLE_CODES = new Set([
+    408, 500, 502, 503, 504, 522, 524, 599,
+]);
 class NetworkCore {
     constructor(options, _emitter) {
         this._emitter = _emitter;
@@ -161,7 +163,7 @@ class NetworkCore {
                 }
                 if (!retries ||
                     currentAttempt > retries ||
-                    !RETRYABLE_CODES.has((_b = response === null || response === void 0 ? void 0 : response.status) !== null && _b !== void 0 ? _b : 500)) {
+                    !exports.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/PendingEvents.d.ts

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,26 @@
+"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;

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.30.1";
+export declare const SDK_VERSION = "3.30.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.30.1';
+exports.SDK_VERSION = '3.30.2-beta.1';
 let metadata = {
     sdkVersion: exports.SDK_VERSION,
     sdkType: 'js-mono', // js-mono is overwritten by Precomp and OnDevice clients

package/src/StorageProvider.js

@@ -75,7 +75,13 @@ exports.Storage = {
 };
 function _getObjectFromStorage(key) {
     const value = exports.Storage.getItem(key);
-    return JSON.parse(value !== null && value !== void 0 ? value : 'null');
+    try {
+        return JSON.parse(value !== null && value !== void 0 ? value : 'null');
+    }
+    catch (e) {
+        Log_1.Log.error(`Failed to parse value for key "${key}"`);
+        return null;
+    }
 }
 exports._getObjectFromStorage = _getObjectFromStorage;
 function _setObjectInStorage(key, obj) {