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

package/src/SessionID.js

@@ -1,14 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StatsigSession = exports.SessionID = void 0;
-const __StatsigGlobal_1 = require("./$_StatsigGlobal");
 const CacheKey_1 = require("./CacheKey");
 const Log_1 = require("./Log");
 const StorageProvider_1 = require("./StorageProvider");
 const UUID_1 = require("./UUID");
+const VisibilityObserving_1 = require("./VisibilityObserving");
 const MAX_SESSION_IDLE_TIME = 30 * 60 * 1000; // 30 minutes
 const MAX_SESSION_AGE = 4 * 60 * 60 * 1000; // 4 hours
-const PROMISE_MAP = {};
+const PERSIST_THROTTLE_MS = 15000;
+const SESSION_MAP = {};
+(0, VisibilityObserving_1._subscribeToVisiblityChanged)((visibility) => {
+    if (visibility === 'background') {
+        Object.values(SESSION_MAP).forEach((session) => _persistNow(session));
+    }
+});
 exports.SessionID = {
     get: (sdkKey) => {
         return exports.StatsigSession.get(sdkKey).data.sessionID;
@@ -16,72 +22,59 @@ exports.SessionID = {
 };
 exports.StatsigSession = {
     get: (sdkKey, bumpSession = true) => {
-        if (PROMISE_MAP[sdkKey] == null) {
-            PROMISE_MAP[sdkKey] = _loadSession(sdkKey);
+        if (SESSION_MAP[sdkKey] == null) {
+            SESSION_MAP[sdkKey] = _loadOrCreateSharedSession(sdkKey);
         }
-        const session = PROMISE_MAP[sdkKey];
-        return bumpSession ? _bumpSession(session) : session;
+        const session = SESSION_MAP[sdkKey];
+        return _maybeBumpSession(session, bumpSession);
     },
     overrideInitialSessionID: (override, sdkKey) => {
-        PROMISE_MAP[sdkKey] = _overrideSessionId(override, sdkKey);
+        const now = Date.now();
+        const session = {
+            data: {
+                sessionID: override,
+                startTime: now,
+                lastUpdate: now,
+            },
+            sdkKey,
+            lastPersistedAt: Date.now(),
+            storageKey: _getSessionIDStorageKey(sdkKey),
+        };
+        _persistNow(session);
+        SESSION_MAP[sdkKey] = session;
+    },
+    checkForIdleSession: (sdkKey) => {
+        const session = SESSION_MAP[sdkKey];
+        if (!session) {
+            return;
+        }
+        const sessionExpired = _checkForExpiredSession(session);
+        if (sessionExpired) {
+            _persistNow(session);
+        }
     },
 };
-function _loadSession(sdkKey) {
-    let data = _loadFromStorage(sdkKey);
+function _maybeBumpSession(session, allowSessionBump) {
     const now = Date.now();
-    if (!data) {
-        data = {
-            sessionID: (0, UUID_1.getUUID)(),
-            startTime: now,
-            lastUpdate: now,
-        };
+    const sessionExpired = _checkForExpiredSession(session);
+    if (sessionExpired) {
+        _persistNow(session);
     }
-    return {
-        data,
-        sdkKey,
-    };
-}
-function _overrideSessionId(override, sdkKey) {
-    const now = Date.now();
-    return {
-        data: {
-            sessionID: override,
-            startTime: now,
-            lastUpdate: now,
-        },
-        sdkKey,
-    };
+    else if (allowSessionBump) {
+        session.data.lastUpdate = now;
+        _persistThrottled(session);
+    }
+    return session;
 }
-function _bumpSession(session) {
+function _checkForExpiredSession(session) {
     var _a;
-    const now = Date.now();
     const data = session.data;
-    const sdkKey = session.sdkKey;
     const sessionExpired = _isIdle(data) || _hasRunTooLong(data);
     if (sessionExpired) {
-        data.sessionID = (0, UUID_1.getUUID)();
-        data.startTime = now;
+        session.data = _newSessionData();
+        (_a = __STATSIG__ === null || __STATSIG__ === void 0 ? void 0 : __STATSIG__.instance(session.sdkKey)) === null || _a === void 0 ? void 0 : _a.$emt({ name: 'session_expired' });
     }
-    data.lastUpdate = now;
-    _persistToStorage(data, session.sdkKey);
-    clearTimeout(session.idleTimeoutID);
-    clearTimeout(session.ageTimeoutID);
-    const lifetime = now - data.startTime;
-    session.idleTimeoutID = _createSessionTimeout(sdkKey, MAX_SESSION_IDLE_TIME);
-    session.ageTimeoutID = _createSessionTimeout(sdkKey, MAX_SESSION_AGE - lifetime);
-    if (sessionExpired) {
-        (_a = __STATSIG__ === null || __STATSIG__ === void 0 ? void 0 : __STATSIG__.instance(sdkKey)) === null || _a === void 0 ? void 0 : _a.$emt({ name: 'session_expired' });
-    }
-    return session;
-}
-function _createSessionTimeout(sdkKey, duration) {
-    return setTimeout(() => {
-        var _a;
-        const client = (_a = (0, __StatsigGlobal_1._getStatsigGlobal)()) === null || _a === void 0 ? void 0 : _a.instance(sdkKey);
-        if (client) {
-            client.$emt({ name: 'session_expired' });
-        }
-    }, duration);
+    return sessionExpired;
 }
 function _isIdle({ lastUpdate }) {
     return Date.now() - lastUpdate > MAX_SESSION_IDLE_TIME;
@@ -92,16 +85,45 @@ function _hasRunTooLong({ startTime }) {
 function _getSessionIDStorageKey(sdkKey) {
     return `statsig.session_id.${(0, CacheKey_1._getStorageKey)(sdkKey)}`;
 }
-function _persistToStorage(session, sdkKey) {
-    const storageKey = _getSessionIDStorageKey(sdkKey);
+function _persistNow(session) {
     try {
-        (0, StorageProvider_1._setObjectInStorage)(storageKey, session);
+        (0, StorageProvider_1._setObjectInStorage)(session.storageKey, session.data);
+        session.lastPersistedAt = Date.now();
     }
     catch (e) {
         Log_1.Log.warn('Failed to save SessionID');
     }
 }
-function _loadFromStorage(sdkKey) {
+function _persistThrottled(session) {
+    const now = Date.now();
+    if (now - session.lastPersistedAt > PERSIST_THROTTLE_MS) {
+        _persistNow(session);
+    }
+}
+function _loadSessionFromStorage(storageKey) {
+    const data = (0, StorageProvider_1._getObjectFromStorage)(storageKey);
+    return data;
+}
+function _loadOrCreateSharedSession(sdkKey) {
     const storageKey = _getSessionIDStorageKey(sdkKey);
-    return (0, StorageProvider_1._getObjectFromStorage)(storageKey);
+    const existing = _loadSessionFromStorage(storageKey);
+    if (existing &&
+        existing.sessionID &&
+        existing.startTime &&
+        existing.lastUpdate) {
+        return { data: existing, sdkKey, lastPersistedAt: 0, storageKey };
+    }
+    return {
+        data: _newSessionData(),
+        sdkKey,
+        lastPersistedAt: 0,
+        storageKey,
+    };
+}
+function _newSessionData() {
+    return {
+        sessionID: (0, UUID_1.getUUID)(),
+        startTime: Date.now(),
+        lastUpdate: Date.now(),
+    };
 }

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.2";
+export declare const SDK_VERSION = "3.31.2";
 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.2';
+exports.SDK_VERSION = '3.31.2';
 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 {};