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

package/src/FlushCoordinator.js

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

@@ -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;