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

package/package.json

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

package/src/BatchedEventsQueue.d.ts

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

package/src/BatchedEventsQueue.js

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

@@ -2,7 +2,7 @@ import { DownloadConfigSpecsResponse } from './DownloadConfigSpecsResponse';
 import { ErrorBoundary } from './ErrorBoundary';
 import { DynamicConfigEvaluationOptions, ExperimentEvaluationOptions, FeatureGateEvaluationOptions, LayerEvaluationOptions, ParameterStoreEvaluationOptions } from './EvaluationOptions';
 import { AnyInitializeResponse, ClientInitializeResponseOptions } from './InitializeResponse';
-import { StatsigSession } from './SessionID';
+import { StatsigSession, StatsigSession as StatsigSessionType } from './SessionID';
 import { StatsigClientEventEmitterInterface } from './StatsigClientEventEmitter';
 import { EvaluationsDataAdapter, SpecsDataAdapter } from './StatsigDataAdapter';
 import { StatsigEvent } from './StatsigEvent';
@@ -48,6 +48,7 @@ export type PrecomputedEvaluationsContext = Flatten<CommonContext & {
 export interface PrecomputedEvaluationsInterface extends StatsigClientCommonInterface {
     readonly dataAdapter: EvaluationsDataAdapter;
     getContext(): PrecomputedEvaluationsContext;
+    getContextHandle(): PrecomputedEvaluationsContextHandle;
     updateUserSync(user: StatsigUser): StatsigUpdateDetails;
     updateUserAsync(user: StatsigUser): Promise<StatsigUpdateDetails>;
     checkGate(name: string, options?: FeatureGateEvaluationOptions): boolean;
@@ -60,3 +61,35 @@ export interface PrecomputedEvaluationsInterface extends StatsigClientCommonInte
     logEvent(eventName: string, value?: string | number, metadata?: Record<string, string>): void;
 }
 export type StatsigClientInterface = OnDeviceEvaluationsInterface | PrecomputedEvaluationsInterface;
+/**
+ * A handle to the PrecomputedEvaluationsContext that computes fields lazily on access.
+ * This avoids unnecessary computation (e.g., cloning the user) when only certain fields are needed.
+ * The handle is created once and reused; individual getters fetch current values on each access.
+ */
+export declare class PrecomputedEvaluationsContextHandle {
+    private _sdkKey;
+    private _getOptions;
+    private _getErrorBoundary;
+    private _getValues;
+    private _getUser;
+    private _getSdkInstanceID;
+    constructor(sdkKey: string, getOptions: () => AnyStatsigOptions, getErrorBoundary: () => ErrorBoundary, getValues: () => AnyInitializeResponse | null, getUser: () => StatsigUser, getSdkInstanceID: () => string);
+    get sdkKey(): string;
+    get options(): AnyStatsigOptions;
+    get errorBoundary(): ErrorBoundary;
+    get values(): AnyInitializeResponse | null;
+    get user(): StatsigUser;
+    /**
+     * Gets the current session.
+     * @param {boolean} [bumpSession=true] - Whether to bump/update the session timing. Set to false to read without affecting session state.
+     */
+    getSession(bumpSession?: boolean): StatsigSessionType;
+    get stableID(): string | null;
+    get sdkInstanceID(): string;
+    /**
+     * Returns the full PrecomputedEvaluationsContext object.
+     * Use this when you need all fields at once.
+     * @param {boolean} [bumpSession=true] - Whether to bump the session when building the context.
+     */
+    toContext(bumpSession?: boolean): PrecomputedEvaluationsContext;
+}

package/src/ClientInterfaces.js

@@ -1,2 +1,73 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrecomputedEvaluationsContextHandle = void 0;
+const Log_1 = require("./Log");
+const SafeJs_1 = require("./SafeJs");
+const SessionID_1 = require("./SessionID");
+const StableID_1 = require("./StableID");
+/**
+ * A handle to the PrecomputedEvaluationsContext that computes fields lazily on access.
+ * This avoids unnecessary computation (e.g., cloning the user) when only certain fields are needed.
+ * The handle is created once and reused; individual getters fetch current values on each access.
+ */
+class PrecomputedEvaluationsContextHandle {
+    constructor(sdkKey, getOptions, getErrorBoundary, getValues, getUser, getSdkInstanceID) {
+        this._sdkKey = sdkKey;
+        this._getOptions = getOptions;
+        this._getErrorBoundary = getErrorBoundary;
+        this._getValues = getValues;
+        this._getUser = getUser;
+        this._getSdkInstanceID = getSdkInstanceID;
+    }
+    get sdkKey() {
+        return this._sdkKey;
+    }
+    get options() {
+        return this._getOptions();
+    }
+    get errorBoundary() {
+        return this._getErrorBoundary();
+    }
+    get values() {
+        return this._getValues();
+    }
+    get user() {
+        let user = (0, SafeJs_1._cloneObject)('StatsigUser', this._getUser());
+        if (user == null) {
+            Log_1.Log.error('Failed to clone user');
+            user = {};
+        }
+        return user;
+    }
+    /**
+     * Gets the current session.
+     * @param {boolean} [bumpSession=true] - Whether to bump/update the session timing. Set to false to read without affecting session state.
+     */
+    getSession(bumpSession = true) {
+        return SessionID_1.StatsigSession.get(this._sdkKey, bumpSession);
+    }
+    get stableID() {
+        return StableID_1.StableID.get(this._sdkKey);
+    }
+    get sdkInstanceID() {
+        return this._getSdkInstanceID();
+    }
+    /**
+     * Returns the full PrecomputedEvaluationsContext object.
+     * Use this when you need all fields at once.
+     * @param {boolean} [bumpSession=true] - Whether to bump the session when building the context.
+     */
+    toContext(bumpSession = true) {
+        return {
+            sdkKey: this.sdkKey,
+            options: this.options,
+            values: this.values,
+            user: this.user,
+            errorBoundary: this.errorBoundary,
+            session: this.getSession(bumpSession),
+            stableID: this.stableID,
+            sdkInstanceID: this.sdkInstanceID,
+        };
+    }
+}
+exports.PrecomputedEvaluationsContextHandle = PrecomputedEvaluationsContextHandle;

package/src/ErrorBoundary.d.ts

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

package/src/ErrorBoundary.js

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