@statsig/client-core 3.0.0-beta.5 → 3.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statsig/client-core",
-  "version": "3.0.0-beta.5",
+  "version": "3.1.0",
   "dependencies": {},
   "type": "commonjs",
   "main": "./src/index.js",

package/src/DownloadConfigSpecsResponse.d.ts

@@ -1,3 +1,4 @@
+import { StatsigUser } from './StatsigUser';
 export type SpecCondition = {
     type: string;
     targetValue: unknown;
@@ -38,4 +39,6 @@ export type DownloadConfigSpecsResponse = {
     layer_configs: Spec[];
     time: number;
     has_updates: boolean;
+    sdkInfo?: Record<string, string>;
+    user?: StatsigUser;
 };

package/src/EvaluationTypes.d.ts

@@ -1,4 +1,5 @@
 import { ParamStoreConfig } from './ParamStoreTypes';
+import { BootstrapMetadata } from './StatsigEvent';
 import { Flatten } from './TypingUtils';
 type EvaluationBase<T> = {
     id_type: string;
@@ -32,9 +33,12 @@ export type EvaluationDetails = {
     reason: string;
     lcut?: number;
     receivedAt?: number;
+    warnings?: EvaluationWarning[];
+    bootstrapMetadata?: BootstrapMetadata;
 };
 export type DetailedStoreResult<T extends AnyEvaluation | ParamStoreConfig> = {
     result: T | null;
     details: EvaluationDetails;
 };
+export type EvaluationWarning = 'PartialUserMatch' | 'StableIDMismatch';
 export {};

package/src/EventLogger.d.ts

@@ -16,6 +16,8 @@ export declare class EventLogger {
     private _creationTime;
     private _isLoggingDisabled;
     private _logEventUrl;
+    private static _safeFlushAndForget;
+    private static _safeRetryFailedLogs;
     constructor(_sdkKey: string, _emitter: StatsigClientEmitEventFunc, _network: NetworkCore, _options: StatsigOptionsCommon<NetworkConfigCommon> | null);
     setLoggingDisabled(isDisabled: boolean): void;
     enqueue(event: StatsigEventInternal): void;

package/src/EventLogger.js

@@ -26,13 +26,22 @@ const DEDUPER_WINDOW_DURATION_MS = 60000;
 const MAX_FAILED_LOGS = 500;
 const QUICK_FLUSH_WINDOW_MS = 200;
 const EVENT_LOGGER_MAP = {};
-const _safeFlushAndForget = (sdkKey) => {
-    var _a;
-    (_a = EVENT_LOGGER_MAP[sdkKey]) === null || _a === void 0 ? void 0 : _a.flush().catch(() => {
-        // noop
-    });
-};
+var RetryFailedLogsTrigger;
+(function (RetryFailedLogsTrigger) {
+    RetryFailedLogsTrigger[RetryFailedLogsTrigger["Startup"] = 0] = "Startup";
+    RetryFailedLogsTrigger[RetryFailedLogsTrigger["GainedFocus"] = 1] = "GainedFocus";
+})(RetryFailedLogsTrigger || (RetryFailedLogsTrigger = {}));
 class EventLogger {
+    static _safeFlushAndForget(sdkKey) {
+        var _a;
+        (_a = EVENT_LOGGER_MAP[sdkKey]) === null || _a === void 0 ? void 0 : _a.flush().catch(() => {
+            // noop
+        });
+    }
+    static _safeRetryFailedLogs(sdkKey) {
+        var _a;
+        (_a = EVENT_LOGGER_MAP[sdkKey]) === null || _a === void 0 ? void 0 : _a._retryFailedLogs(RetryFailedLogsTrigger.GainedFocus);
+    }
     constructor(_sdkKey, _emitter, _network, _options) {
         var _a;
         this._sdkKey = _sdkKey;
@@ -59,7 +68,7 @@ class EventLogger {
         this._normalizeAndAppendEvent(event);
         this._quickFlushIfNeeded();
         if (this._queue.length > this._maxQueueSize) {
-            _safeFlushAndForget(this._sdkKey);
+            EventLogger._safeFlushAndForget(this._sdkKey);
         }
     }
     incrementNonExposureCount(name) {
@@ -77,10 +86,13 @@ class EventLogger {
         EVENT_LOGGER_MAP[this._sdkKey] = this;
         (0, VisibilityObserving_1._subscribeToVisiblityChanged)((visibility) => {
             if (visibility === 'background') {
-                _safeFlushAndForget(this._sdkKey);
+                EventLogger._safeFlushAndForget(this._sdkKey);
+            }
+            else if (visibility === 'foreground') {
+                EventLogger._safeRetryFailedLogs(this._sdkKey);
             }
         });
-        this._retryFailedLogs();
+        this._retryFailedLogs(RetryFailedLogsTrigger.Startup);
         this._startBackgroundFlushInterval();
     }
     stop() {
@@ -100,7 +112,7 @@ class EventLogger {
             }
             const events = this._queue;
             this._queue = [];
-            return this._sendEvents(events);
+            yield this._sendEvents(events);
         });
     }
     /**
@@ -115,7 +127,7 @@ class EventLogger {
         if (Date.now() - this._creationTime > QUICK_FLUSH_WINDOW_MS) {
             return;
         }
-        setTimeout(() => _safeFlushAndForget(this._sdkKey), QUICK_FLUSH_WINDOW_MS);
+        setTimeout(() => EventLogger._safeFlushAndForget(this._sdkKey), QUICK_FLUSH_WINDOW_MS);
     }
     _shouldLogEvent(event) {
         if ((0, SafeJs_1._isServerEnv)()) {
@@ -150,7 +162,7 @@ class EventLogger {
         return __awaiter(this, void 0, void 0, function* () {
             if (this._isLoggingDisabled) {
                 this._saveFailedLogsToStorage(events);
-                return;
+                return false;
             }
             try {
                 const isInBackground = !(0, VisibilityObserving_1._isCurrentlyVisible)();
@@ -165,13 +177,17 @@ class EventLogger {
                         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;
             }
         });
     }
@@ -216,7 +232,7 @@ class EventLogger {
             Log_1.Log.warn('Unable to save failed logs to storage');
         }
     }
-    _retryFailedLogs() {
+    _retryFailedLogs(trigger) {
         const storageKey = this._getStorageKey();
         (() => __awaiter(this, void 0, void 0, function* () {
             if (!StorageProvider_1.Storage.isReady()) {
@@ -226,8 +242,13 @@ class EventLogger {
             if (!events) {
                 return;
             }
-            StorageProvider_1.Storage.removeItem(storageKey);
-            yield this._sendEvents(events);
+            if (trigger === RetryFailedLogsTrigger.Startup) {
+                StorageProvider_1.Storage.removeItem(storageKey);
+            }
+            const isSuccess = yield this._sendEvents(events);
+            if (isSuccess && trigger === RetryFailedLogsTrigger.GainedFocus) {
+                StorageProvider_1.Storage.removeItem(storageKey);
+            }
         }))().catch(() => {
             Log_1.Log.warn('Failed to flush stored logs');
         });
@@ -279,7 +300,7 @@ class EventLogger {
                 clearInterval(intervalId);
             }
             else {
-                _safeFlushAndForget(this._sdkKey);
+                EventLogger._safeFlushAndForget(this._sdkKey);
             }
         }, flushInterval);
         this._flushIntervalId = intervalId;

package/src/InitializeResponse.d.ts

@@ -20,6 +20,7 @@ export type InitializeResponseWithUpdates = SessionReplayFields & AutoCaptureFie
     hash_used: 'none' | 'sha256' | 'djb2';
     derived_fields?: Record<string, unknown>;
     user?: StatsigUser;
+    sdkInfo?: Record<string, string>;
 };
 export type InitializeResponse = InitializeResponseWithUpdates | {
     has_updates: false;

package/src/Log.js

@@ -22,22 +22,22 @@ var LogLevel;
 class Log {
     static info(...args) {
         if (this.level >= LogLevel.Info) {
-            console.info('\x1b[34m%s\x1b[0m', _INFO, ...addTag(args));
+            console.info(_INFO, ...addTag(args));
         }
     }
     static debug(...args) {
         if (this.level >= LogLevel.Debug) {
-            console.debug('\x1b[32m%s\x1b[0m', DEBUG, ...addTag(args));
+            console.debug(DEBUG, ...addTag(args));
         }
     }
     static warn(...args) {
         if (this.level >= LogLevel.Warn) {
-            console.warn('\x1b[33m%s\x1b[0m', _WARN, ...addTag(args));
+            console.warn(_WARN, ...addTag(args));
         }
     }
     static error(...args) {
         if (this.level >= LogLevel.Error) {
-            console.error('\x1b[31m%s\x1b[0m', ERROR, ...addTag(args));
+            console.error(ERROR, ...addTag(args));
         }
     }
 }

package/src/StatsigClientEventEmitter.d.ts

@@ -15,6 +15,7 @@ type EventNameToEventDataMap = {
         events: Record<string, unknown>[];
     };
     pre_shutdown: object;
+    initialization_failure: object;
     gate_evaluation: {
         gate: FeatureGate;
     };

package/src/StatsigDataAdapter.d.ts

@@ -29,9 +29,10 @@ export type DataAdapterAsyncOptions = {
 export type DataAdapterSyncOptions = {
     /**
      * The flag to disable background cache refresh.
-     * If set to true, the cache will not be updated in the background and will only use the data adatpter values.
+     * If set to true, a network request to update the cache for future sessions will not fired.
+     * if "explicitly" set to false, a network request to update the cache for future sessions will be fired, even in bootstrap cases.
      *
-     * default: false
+     * default: implicit false
      */
     readonly disableBackgroundCacheRefresh?: boolean;
 };

package/src/StatsigEvent.d.ts

@@ -8,6 +8,11 @@ export type StatsigEvent = {
         [key: string]: string | undefined;
     } | null;
 };
+export type BootstrapMetadata = {
+    generatorSDKInfo?: Record<string, string>;
+    lcut?: number;
+    user?: Record<string, unknown>;
+};
 export type StatsigEventInternal = Omit<StatsigEvent, 'metadata'> & {
     user: StatsigUserInternal | null;
     time: number;

package/src/StatsigEvent.js

@@ -5,6 +5,9 @@ const CONFIG_EXPOSURE_NAME = 'statsig::config_exposure';
 const GATE_EXPOSURE_NAME = 'statsig::gate_exposure';
 const LAYER_EXPOSURE_NAME = 'statsig::layer_exposure';
 const _createExposure = (eventName, user, details, metadata, secondaryExposures) => {
+    if (details.bootstrapMetadata) {
+        metadata['bootstrapMetadata'] = details.bootstrapMetadata;
+    }
     return {
         eventName,
         user,

package/src/StatsigMetadata.d.ts

@@ -1,4 +1,4 @@
-export declare const SDK_VERSION = "3.0.0-beta.5";
+export declare const SDK_VERSION = "3.1.0";
 export type StatsigMetadata = {
     readonly [key: string]: string | undefined;
     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.0.0-beta.5';
+exports.SDK_VERSION = '3.1.0';
 let metadata = {
     sdkVersion: exports.SDK_VERSION,
     sdkType: 'js-mono', // js-mono is overwritten by Precomp and OnDevice clients