@statsig/client-core 1.7.0 → 1.8.0-beta.10

package/package.json

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

package/src/ClientInterfaces.d.ts

@@ -21,18 +21,14 @@ export type CommonContext = {
     sdkKey: string;
     options: AnyStatsigOptions;
     errorBoundary: ErrorBoundary;
-};
-export type AsyncCommonContext = {
     session: StatsigSession;
     stableID: string;
 };
 export type OnDeviceEvaluationsContext = CommonContext & {
     values: DownloadConfigSpecsResponse | null;
 };
-export type OnDeviceEvaluationsAsyncContext = OnDeviceEvaluationsContext & AsyncCommonContext;
 export interface OnDeviceEvaluationsInterface extends StatsigClientCommonInterface {
     readonly dataAdapter: SpecsDataAdapter;
-    getAsyncContext(): Promise<OnDeviceEvaluationsAsyncContext>;
     getContext(): OnDeviceEvaluationsContext;
     checkGate(name: string, user: StatsigUser, options?: FeatureGateEvaluationOptions): boolean;
     getFeatureGate(name: string, user: StatsigUser, options?: FeatureGateEvaluationOptions): FeatureGate;
@@ -46,10 +42,8 @@ export type PrecomputedEvaluationsContext = Flatten<CommonContext & {
     values: InitializeResponseWithUpdates | null;
     user: StatsigUser;
 }>;
-export type PrecomputedEvaluationsAsyncContext = Flatten<AsyncCommonContext & PrecomputedEvaluationsContext>;
 export interface PrecomputedEvaluationsInterface extends StatsigClientCommonInterface {
     readonly dataAdapter: EvaluationsDataAdapter;
-    getAsyncContext(): Promise<PrecomputedEvaluationsAsyncContext>;
     getContext(): PrecomputedEvaluationsContext;
     updateUserSync(user: StatsigUser): void;
     updateUserAsync(user: StatsigUser): Promise<void>;

package/src/DataAdapterCore.js

@@ -118,7 +118,7 @@ class DataAdapterCore {
     }
     _loadFromCache(cacheKey) {
         var _a;
-        const cache = (_a = StorageProvider_1.Storage._getItemSync) === null || _a === void 0 ? void 0 : _a.call(StorageProvider_1.Storage, cacheKey);
+        const cache = (_a = StorageProvider_1.Storage._getItem) === null || _a === void 0 ? void 0 : _a.call(StorageProvider_1.Storage, cacheKey);
         if (cache == null) {
             return null;
         }

package/src/Diagnostics.d.ts

@@ -1,3 +1,67 @@
-export declare abstract class Diagnostics {
-    static mark(): void;
+import { EvaluationDetails } from './EvaluationTypes';
+import { EventLogger } from './EventLogger';
+import { NetworkConfigCommon, StatsigOptionsCommon } from './StatsigOptionsCommon';
+import { StatsigUserInternal } from './StatsigUser';
+export type KeyType = 'initialize' | 'overall';
+export type StepType = 'process' | 'network_request';
+export type ActionType = 'start' | 'end';
+export interface Marker {
+    key: KeyType;
+    action: ActionType;
+    timestamp: number;
+    step?: StepType;
+    statusCode?: number;
+    success?: boolean;
+    url?: string;
+    idListCount?: number;
+    sdkRegion?: string | null;
+    markerID?: string;
+    attempt?: number;
+    isRetry?: boolean;
+    configName?: string;
+    message?: string | null;
+    evaluationDetails?: EvaluationDetails;
+    error?: Record<string, unknown>;
+    isDelta?: boolean;
 }
+export declare const Diagnostics: {
+    _getMarkers: (sdkKey: string) => Marker[] | undefined;
+    _markInitOverallStart: (sdkKey: string) => void;
+    _markInitOverallEnd: (sdkKey: string, success: boolean, evaluationDetails?: EvaluationDetails) => void;
+    _markInitNetworkReqStart: (sdkKey: string, data: InitializeDataType['networkRequest']['start']) => void;
+    _markInitNetworkReqEnd: (sdkKey: string, data: InitializeDataType['networkRequest']['end']) => void;
+    _markInitProcessStart: (sdkKey: string) => void;
+    _markInitProcessEnd: (sdkKey: string, data: InitializeDataType['process']['end']) => void;
+    _clearMarkers: (sdkKey: string) => void;
+    _formatError(e: unknown): Record<string, unknown> | undefined;
+    _getDiagnosticsData(res: Response | null, attempt: number, body: string, e?: unknown): {
+        success: boolean;
+        isDelta?: boolean | undefined;
+        sdkRegion?: string | null | undefined;
+        statusCode?: number | undefined;
+        attempt: number;
+        error?: Record<string, unknown> | undefined;
+    };
+    _enqueueDiagnosticsEvent(user: StatsigUserInternal | null, logger: EventLogger, sdk: string, options: StatsigOptionsCommon<NetworkConfigCommon> | null): void;
+};
+interface InitializeDataType {
+    process: {
+        end: {
+            success: boolean;
+        };
+    };
+    networkRequest: {
+        start: {
+            attempt: number;
+        };
+        end: {
+            success: boolean;
+            attempt: number;
+            isDelta?: boolean;
+            sdkRegion?: string | null;
+            statusCode?: number;
+            error?: Record<string, unknown>;
+        };
+    };
+}
+export {};

package/src/Diagnostics.js

@@ -1,9 +1,98 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Diagnostics = void 0;
-class Diagnostics {
-    static mark() {
-        //
+const MARKER_MAP = new Map();
+const ACT_START = 'start';
+const ACT_END = 'end';
+const DIAGNOSTICS_EVENT = 'statsig::diagnostics';
+exports.Diagnostics = {
+    _getMarkers: (sdkKey) => {
+        return MARKER_MAP.get(sdkKey);
+    },
+    _markInitOverallStart: (sdkKey) => {
+        _addMarker(sdkKey, _createMarker({}, ACT_START));
+    },
+    _markInitOverallEnd: (sdkKey, success, evaluationDetails) => {
+        _addMarker(sdkKey, _createMarker({
+            success,
+            error: success
+                ? undefined
+                : { name: 'InitializeError', message: 'Failed to initialize' },
+            evaluationDetails,
+        }, ACT_END));
+    },
+    _markInitNetworkReqStart: (sdkKey, data) => {
+        _addMarker(sdkKey, _createMarker(data, ACT_START));
+    },
+    _markInitNetworkReqEnd: (sdkKey, data) => {
+        _addMarker(sdkKey, _createMarker(data, ACT_END));
+    },
+    _markInitProcessStart: (sdkKey) => {
+        _addMarker(sdkKey, _createMarker({}, ACT_START));
+    },
+    _markInitProcessEnd: (sdkKey, data) => {
+        _addMarker(sdkKey, _createMarker(data, ACT_END));
+    },
+    _clearMarkers: (sdkKey) => {
+        MARKER_MAP.delete(sdkKey);
+    },
+    _formatError(e) {
+        if (!(e && typeof e === 'object')) {
+            return;
+        }
+        return {
+            code: _safeGetField(e, 'code'),
+            name: _safeGetField(e, 'name'),
+            message: _safeGetField(e, 'message'),
+        };
+    },
+    _getDiagnosticsData(res, attempt, body, e) {
+        var _a;
+        return {
+            success: (res === null || res === void 0 ? void 0 : res.ok) === true,
+            statusCode: res === null || res === void 0 ? void 0 : res.status,
+            sdkRegion: (_a = res === null || res === void 0 ? void 0 : res.headers) === null || _a === void 0 ? void 0 : _a.get('x-statsig-region'),
+            isDelta: body.includes('"is_delta":true') === true ? true : undefined,
+            attempt,
+            error: exports.Diagnostics._formatError(e),
+        };
+    },
+    _enqueueDiagnosticsEvent(user, logger, sdk, options) {
+        const markers = exports.Diagnostics._getMarkers(sdk);
+        if (markers == null || markers.length <= 0) {
+            return;
+        }
+        exports.Diagnostics._clearMarkers(sdk);
+        const event = _makeDiagnosticsEvent(user, {
+            context: 'initialize',
+            markers: markers.slice(),
+            statsigOptions: options,
+        });
+        logger.enqueue(event);
+    },
+};
+function _createMarker(data, action) {
+    return Object.assign({ key: 'initialize', action: action, timestamp: Date.now() }, data);
+}
+function _makeDiagnosticsEvent(user, data) {
+    const latencyEvent = {
+        eventName: DIAGNOSTICS_EVENT,
+        user,
+        value: null,
+        metadata: data,
+        time: Date.now(),
+    };
+    return latencyEvent;
+}
+function _addMarker(sdkKey, marker) {
+    var _a;
+    const markers = (_a = MARKER_MAP.get(sdkKey)) !== null && _a !== void 0 ? _a : [];
+    markers.push(marker);
+    MARKER_MAP.set(sdkKey, markers);
+}
+function _safeGetField(data, field) {
+    if (field in data) {
+        return data[field];
     }
+    return undefined;
 }
-exports.Diagnostics = Diagnostics;

package/src/EventLogger.js

@@ -118,6 +118,9 @@ class EventLogger {
         setTimeout(() => _safeFlushAndForget(this._sdkKey), QUICK_FLUSH_WINDOW_MS);
     }
     _shouldLogEvent(event) {
+        if ((0, SafeJs_1._isServerEnv)()) {
+            return false; // do not run in server environments
+        }
         if (!(0, StatsigEvent_1._isExposureEvent)(event)) {
             return true;
         }
@@ -206,18 +209,21 @@ class EventLogger {
             events.shift();
         }
         const storageKey = this._getStorageKey();
-        (0, StorageProvider_1._setObjectInStorage)(storageKey, events).catch(() => {
+        try {
+            (0, StorageProvider_1._setObjectInStorage)(storageKey, events);
+        }
+        catch (_a) {
             Log_1.Log.warn('Unable to save failed logs to storage');
-        });
+        }
     }
     _retryFailedLogs() {
         const storageKey = this._getStorageKey();
         (() => __awaiter(this, void 0, void 0, function* () {
-            const events = yield (0, StorageProvider_1._getObjectFromStorage)(storageKey);
+            const events = (0, StorageProvider_1._getObjectFromStorage)(storageKey);
             if (!events) {
                 return;
             }
-            yield StorageProvider_1.Storage._removeItem(storageKey);
+            StorageProvider_1.Storage._removeItem(storageKey);
             yield this._sendEvents(events);
         }))().catch(() => {
             Log_1.Log.warn('Failed to flush stored logs');

package/src/InitializeResponse.d.ts

@@ -5,7 +5,12 @@ type SessionReplayFields = {
     can_record_session?: boolean;
     session_recording_rate?: number;
 };
-export type InitializeResponseWithUpdates = SessionReplayFields & {
+type AutoCaptureFields = {
+    auto_capture_settings?: {
+        disabled_events: Record<string, boolean>;
+    };
+};
+export type InitializeResponseWithUpdates = SessionReplayFields & AutoCaptureFields & {
     feature_gates: Record<string, GateEvaluation>;
     dynamic_configs: Record<string, DynamicConfigEvaluation>;
     layer_configs: Record<string, LayerEvaluation>;

package/src/NetworkConfig.d.ts

@@ -1,7 +1,7 @@
 export declare const NetworkDefault: {
-    eventsApi: "https://prodregistryv2.org/v1";
-    initializeApi: "https://featureassets.org/v1";
-    specsApi: "https://assetsconfigcdn.org/v1";
+    eventsApi: "https://statsigapi.net/v1";
+    initializeApi: "https://statsigapi.net/v1";
+    specsApi: "https://statsigapi.net/v1";
 };
 export type NetworkPriority = 'high' | 'low' | 'auto';
 export type NetworkArgs = RequestInit & {

package/src/NetworkConfig.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NetworkParam = exports.NetworkDefault = void 0;
 exports.NetworkDefault = {
-    eventsApi: 'https://prodregistryv2.org/v1',
-    initializeApi: 'https://featureassets.org/v1',
-    specsApi: 'https://assetsconfigcdn.org/v1',
+    eventsApi: 'https://statsigapi.net/v1',
+    initializeApi: 'https://statsigapi.net/v1',
+    specsApi: 'https://statsigapi.net/v1',
 };
 var NetworkParam;
 (function (NetworkParam) {

package/src/NetworkCore.d.ts

@@ -8,6 +8,8 @@ type RequestArgs = {
     url: string;
     priority?: NetworkPriority;
     retries?: number;
+    attempt?: number;
+    isInitialize?: boolean;
     params?: Record<string, string>;
     headers?: Record<string, string>;
 };
@@ -16,7 +18,7 @@ export type RequestArgsWithData = Flatten<RequestArgs & {
     isStatsigEncodable?: boolean;
     isCompressable?: boolean;
 }>;
-type BeaconRequestArgs = Pick<RequestArgsWithData, 'data' | 'sdkKey' | 'url' | 'params' | 'isCompressable'>;
+type BeaconRequestArgs = Pick<RequestArgsWithData, 'data' | 'sdkKey' | 'url' | 'params' | 'isCompressable' | 'attempt'>;
 type NetworkResponse = {
     body: string | null;
     code: number;
@@ -26,6 +28,9 @@ export declare class NetworkCore {
     private readonly _timeout;
     private readonly _netConfig;
     private readonly _options;
+    private _proxy;
+    private networkEvents;
+    private sdkKey;
     constructor(options: AnyStatsigOptions | null, _emitter?: StatsigClientEmitEventFunc | undefined);
     post(args: RequestArgsWithData): Promise<NetworkResponse | null>;
     get(args: RequestArgs): Promise<NetworkResponse | null>;
@@ -35,5 +40,8 @@ export declare class NetworkCore {
     private _getPopulatedURL;
     private _getPopulatedBody;
     private _attemptToEncodeString;
+    private _getNetworkProxyArgs;
+    private _flushNetworkEvents;
+    private _startBackgroundFlushNetworkEvents;
 }
 export {};

package/src/NetworkCore.js

@@ -15,6 +15,7 @@ const __StatsigGlobal_1 = require("./$_StatsigGlobal");
 const Diagnostics_1 = require("./Diagnostics");
 const Log_1 = require("./Log");
 const NetworkConfig_1 = require("./NetworkConfig");
+const NetworkProxy_1 = require("./NetworkProxy");
 const SDKType_1 = require("./SDKType");
 const SafeJs_1 = require("./SafeJs");
 const SessionID_1 = require("./SessionID");
@@ -22,12 +23,15 @@ const StableID_1 = require("./StableID");
 const StatsigMetadata_1 = require("./StatsigMetadata");
 const VisibilityObserving_1 = require("./VisibilityObserving");
 const DEFAULT_TIMEOUT_MS = 10000;
+const RETRYABLE_CODES = new Set([408, 500, 502, 503, 504, 522, 524, 599]);
 class NetworkCore {
     constructor(options, _emitter) {
         this._emitter = _emitter;
         this._timeout = DEFAULT_TIMEOUT_MS;
         this._netConfig = {};
         this._options = {};
+        this.networkEvents = [];
+        this.sdkKey = null;
         if (options) {
             this._options = options;
         }
@@ -37,17 +41,26 @@ class NetworkCore {
         if (this._netConfig.networkTimeoutMs) {
             this._timeout = this._netConfig.networkTimeoutMs;
         }
+        this._proxy = new NetworkProxy_1.NetworkProxy(this._options);
+        this._startBackgroundFlushNetworkEvents();
     }
     post(args) {
         return __awaiter(this, void 0, void 0, function* () {
-            let body = yield this._getPopulatedBody(args);
+            const proxyConfigArgs = this._getNetworkProxyArgs(args);
+            if (!this.sdkKey) {
+                this.sdkKey = args.sdkKey;
+            }
+            let body = yield this._getPopulatedBody(Object.assign(Object.assign({}, args), proxyConfigArgs));
             if (args.isStatsigEncodable) {
                 body = this._attemptToEncodeString(args, body);
             }
-            return this._sendRequest(Object.assign({ method: 'POST', body }, args));
+            return this._sendRequest(Object.assign(Object.assign({ method: 'POST', body }, proxyConfigArgs), args));
         });
     }
     get(args) {
+        if (!this.sdkKey) {
+            this.sdkKey = args.sdkKey;
+        }
         return this._sendRequest(Object.assign({ method: 'GET' }, args));
     }
     isBeaconSupported() {
@@ -59,14 +72,15 @@ class NetworkCore {
             if (!_ensureValidSdkKey(args)) {
                 return false;
             }
-            const body = yield this._getPopulatedBody(args);
-            const url = yield this._getPopulatedURL(args);
+            const networkProxyArgs = this._getNetworkProxyArgs(args);
+            const body = yield this._getPopulatedBody(Object.assign(Object.assign({}, args), networkProxyArgs));
+            const url = yield this._getPopulatedURL(Object.assign(Object.assign({}, args), networkProxyArgs));
             const nav = navigator;
             return nav.sendBeacon.bind(nav)(url, body);
         });
     }
     _sendRequest(args) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
             if (!_ensureValidSdkKey(args)) {
                 return null;
@@ -74,10 +88,17 @@ class NetworkCore {
             if (this._netConfig.preventAllNetworkTraffic) {
                 return null;
             }
-            const { method, body, retries } = args;
+            const { method, body, retries, attempt } = args;
+            const currentAttempt = attempt !== null && attempt !== void 0 ? attempt : 1;
             const controller = typeof AbortController !== 'undefined' ? new AbortController() : null;
-            const handle = setTimeout(() => controller === null || controller === void 0 ? void 0 : controller.abort(`Timeout of ${this._timeout}ms expired.`), this._timeout);
-            const url = yield this._getPopulatedURL(args);
+            const handle = setTimeout(() => {
+                controller === null || controller === void 0 ? void 0 : controller.abort(`Timeout of ${this._timeout}ms expired.`);
+            }, this._timeout);
+            const proxyUrl = (_a = args.proxyUrl) !== null && _a !== void 0 ? _a : this._proxy.getProxyUrl(args.sdkKey, args.url);
+            const url = yield this._getPopulatedURL(Object.assign({ proxyUrl }, args));
+            const isProxy = !url.includes('https://statsigapi.net/v1');
+            const parsedUrl = new URL(url);
+            const endpoint = parsedUrl.pathname;
             let response = null;
             const keepalive = (0, VisibilityObserving_1._isUnloading)();
             try {
@@ -89,43 +110,87 @@ class NetworkCore {
                     priority: args.priority,
                     keepalive,
                 };
-                const func = (_a = this._netConfig.networkOverrideFunc) !== null && _a !== void 0 ? _a : fetch;
+                if (args.isInitialize) {
+                    Diagnostics_1.Diagnostics._markInitNetworkReqStart(args.sdkKey, {
+                        attempt: currentAttempt,
+                    });
+                }
+                const func = (_b = this._netConfig.networkOverrideFunc) !== null && _b !== void 0 ? _b : fetch;
                 response = yield func(url, config);
                 clearTimeout(handle);
                 if (!response.ok) {
                     const text = yield response.text().catch(() => 'No Text');
                     const err = new Error(`NetworkError: ${url} ${text}`);
+                    console.log('response not ok!!', err);
                     err.name = 'NetworkError';
                     throw err;
                 }
                 const text = yield response.text();
-                Diagnostics_1.Diagnostics.mark();
+                if (args.isInitialize) {
+                    Diagnostics_1.Diagnostics._markInitNetworkReqEnd(args.sdkKey, Diagnostics_1.Diagnostics._getDiagnosticsData(response, currentAttempt, text));
+                }
+                console.log('network success!!');
+                if (!url.includes('https://prodregistryv2.org')) {
+                    this.networkEvents.push({
+                        value: isProxy ? 'proxy' : 'statsig',
+                        eventName: 'proxy::network_request_tracking',
+                        metadata: {
+                            url,
+                            success: true,
+                            endpoint,
+                        },
+                        time: Date.now(),
+                        user: null,
+                    });
+                }
                 return {
                     body: text,
                     code: response.status,
                 };
             }
             catch (error) {
+                console.log('network error!!', error);
+                if (!url.includes('https://prodregistryv2.org')) {
+                    this.networkEvents.push({
+                        value: isProxy ? 'proxy' : 'statsig',
+                        eventName: 'proxy::network_request_tracking',
+                        metadata: {
+                            url,
+                            success: false,
+                            endpoint,
+                        },
+                        time: Date.now(),
+                        user: null,
+                    });
+                }
                 const errorMessage = _getErrorMessage(controller, error);
-                Diagnostics_1.Diagnostics.mark();
-                if (!retries || retries <= 0) {
-                    (_b = this._emitter) === null || _b === void 0 ? void 0 : _b.call(this, { name: 'error', error });
+                const timedOut = _didTimeout(controller);
+                if (args.isInitialize) {
+                    Diagnostics_1.Diagnostics._markInitNetworkReqEnd(args.sdkKey, Diagnostics_1.Diagnostics._getDiagnosticsData(response, currentAttempt, '', error));
+                }
+                yield this._proxy.attemptToUpdateProxyUrl(args.sdkKey, errorMessage, timedOut);
+                if (!retries ||
+                    currentAttempt > retries ||
+                    !RETRYABLE_CODES.has((_c = response === null || response === void 0 ? void 0 : response.status) !== null && _c !== void 0 ? _c : 500)) {
+                    (_d = this._emitter) === null || _d === void 0 ? void 0 : _d.call(this, { name: 'error', error });
                     Log_1.Log.error(`A networking error occured during ${method} request to ${url}.`, errorMessage, error);
                     return null;
                 }
-                return this._sendRequest(Object.assign(Object.assign({}, args), { retries: retries - 1 }));
+                return this._sendRequest(Object.assign(Object.assign({}, args), { retries: retries, attempt: currentAttempt + 1 }));
             }
         });
     }
     _getPopulatedURL(args) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            const url = (_a = args.proxyUrl) !== null && _a !== void 0 ? _a : args.url;
             const params = Object.assign({ [NetworkConfig_1.NetworkParam.SdkKey]: args.sdkKey, [NetworkConfig_1.NetworkParam.SdkType]: SDKType_1.SDKType._get(args.sdkKey), [NetworkConfig_1.NetworkParam.SdkVersion]: StatsigMetadata_1.SDK_VERSION, [NetworkConfig_1.NetworkParam.Time]: String(Date.now()), [NetworkConfig_1.NetworkParam.SessionID]: yield SessionID_1.SessionID.get(args.sdkKey) }, args.params);
             const query = Object.keys(params)
                 .map((key) => {
                 return `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`;
             })
                 .join('&');
-            return `${args.url}${query ? `?${query}` : ''}`;
+            return `${url}${query ? `?${query}` : ''}`;
         });
     }
     _getPopulatedBody(args) {
@@ -136,7 +201,7 @@ class NetworkCore {
             const sdkType = SDKType_1.SDKType._get(sdkKey);
             return JSON.stringify(Object.assign(Object.assign({}, data), { statsigMetadata: Object.assign(Object.assign({}, StatsigMetadata_1.StatsigMetadataProvider.get()), { stableID,
                     sessionID,
-                    sdkType }) }));
+                    sdkType, proxyUrl: args.proxyUrl }) }));
         });
     }
     _attemptToEncodeString(args, input) {
@@ -158,6 +223,32 @@ class NetworkCore {
             return input;
         }
     }
+    _getNetworkProxyArgs(args) {
+        const proxyUrl = this._proxy.getProxyUrl(args.sdkKey, args.url);
+        return {
+            proxyUrl: proxyUrl !== null && proxyUrl !== void 0 ? proxyUrl : null,
+        };
+    }
+    _flushNetworkEvents() {
+        var _a;
+        if (this.networkEvents.length === 0) {
+            return;
+        }
+        console.log('flushing network events!!', this.networkEvents);
+        this.post({
+            sdkKey: (_a = this.sdkKey) !== null && _a !== void 0 ? _a : '',
+            url: 'https://prodregistryv2.org/v1/rgstr',
+            data: {
+                events: [...this.networkEvents],
+            },
+        });
+        this.networkEvents = [];
+    }
+    _startBackgroundFlushNetworkEvents() {
+        setInterval(() => {
+            this._flushNetworkEvents();
+        }, 10000);
+    }
 }
 exports.NetworkCore = NetworkCore;
 const _ensureValidSdkKey = (args) => {
@@ -180,3 +271,9 @@ function _getErrorMessage(controller, error) {
     }
     return 'Unknown Error';
 }
+function _didTimeout(controller) {
+    const timeout = (controller === null || controller === void 0 ? void 0 : controller.signal.aborted) &&
+        typeof controller.signal.reason === 'string' &&
+        controller.signal.reason.includes('Timeout');
+    return timeout || false;
+}

package/src/NetworkProxy.d.ts

@@ -0,0 +1,14 @@
+import { NetworkArgs } from './NetworkConfig';
+import { AnyStatsigOptions } from './StatsigOptionsCommon';
+export declare class NetworkProxy {
+    private _options;
+    private _proxyUrl;
+    private _expiryTime;
+    private _overrideFn;
+    constructor(_options: AnyStatsigOptions);
+    setOverrideFunc(networkOverrideFunc?: (url: string, args: NetworkArgs) => Promise<Response>): void;
+    getProxyUrl(sdkKey: string, url: string): string | null;
+    attemptToUpdateProxyUrl(sdkKey: string, errorMessage: string | null, timedOut: boolean): Promise<void>;
+    private _fetchProxyUrl;
+    private _getTxtEntries;
+}

package/src/NetworkProxy.js

@@ -0,0 +1,199 @@
+"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.NetworkProxy = void 0;
+const Hashing_1 = require("./Hashing");
+const NetworkConfig_1 = require("./NetworkConfig");
+const StorageProvider_1 = require("./StorageProvider");
+const TypedJsonParse_1 = require("./TypedJsonParse");
+const DNS_QUERY_ENDPOINT = 'https://cloudflare-dns.com/dns-query';
+const DNS_QUERY_DOMAIN = 'featureregistry.org';
+const DEFAULT_TTL = 72 * 60 * 60 * 1000; // 72 hours
+class NetworkProxy {
+    constructor(_options) {
+        this._options = _options;
+        this._proxyUrl = null;
+        this._expiryTime = 0;
+        this._overrideFn = undefined;
+        if (_options.networkConfig) {
+            const netConfig = _options.networkConfig;
+            this.setOverrideFunc(netConfig.networkOverrideFunc);
+        }
+    }
+    setOverrideFunc(networkOverrideFunc) {
+        this._overrideFn = networkOverrideFunc;
+    }
+    getProxyUrl(sdkKey, url) {
+        if (!_isDefaultUrl(url)) {
+            return null;
+        }
+        const endpoint = getEndpoint(url);
+        if (this._expiryTime > 0 && Date.now() > this._expiryTime) {
+            this._proxyUrl = null;
+            this._expiryTime = 0;
+            return this._proxyUrl;
+        }
+        if (this._proxyUrl) {
+            return this._proxyUrl + endpoint;
+        }
+        const hashkey = _getProxyStorageKey(sdkKey);
+        const cacheProxy = _getProxyFromCache(hashkey);
+        if (cacheProxy) {
+            this._proxyUrl = cacheProxy.url;
+            this._expiryTime = cacheProxy.expiryTime;
+            return this._proxyUrl + endpoint;
+        }
+        return null;
+    }
+    attemptToUpdateProxyUrl(sdkKey, errorMessage, timedOut) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!_containsUnresolvedDomain(errorMessage, timedOut)) {
+                return;
+            }
+            const hashkey = _getProxyStorageKey(sdkKey);
+            const fetchedProxyUrl = yield this._fetchProxyUrl();
+            if (!fetchedProxyUrl) {
+                return;
+            }
+            this._proxyUrl = fetchedProxyUrl;
+            this._expiryTime = Date.now() + DEFAULT_TTL;
+            StorageProvider_1.Storage._setItem(hashkey, JSON.stringify({ url: this._proxyUrl, expiryTime: this._expiryTime }));
+        });
+    }
+    _fetchProxyUrl() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const txtEntries = yield this._getTxtEntries(DNS_QUERY_DOMAIN);
+            if (txtEntries.length === 0) {
+                return null;
+            }
+            return _findClosestProxy(txtEntries);
+        });
+    }
+    _getTxtEntries(domain) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const body = _encodeDomain(domain);
+            const func = (_a = this._overrideFn) !== null && _a !== void 0 ? _a : fetch;
+            const res = yield func(DNS_QUERY_ENDPOINT, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/dns-message',
+                    Accept: 'application/dns-message',
+                },
+                body,
+            });
+            if (!res.ok) {
+                return [];
+            }
+            const arrBuff = yield res.arrayBuffer();
+            return _decodeDnsResponse(arrBuff);
+        });
+    }
+}
+exports.NetworkProxy = NetworkProxy;
+function _getProxyStorageKey(sdkKey) {
+    return `statsig.proxy.${(0, Hashing_1._DJB2)(sdkKey)}`;
+}
+function _getProxyFromCache(hashKey) {
+    const cacheProxyStr = StorageProvider_1.Storage._getItem(hashKey);
+    if (!cacheProxyStr) {
+        return null;
+    }
+    const cacheProxy = (0, TypedJsonParse_1._typedJsonParse)(cacheProxyStr, 'url', 'cacheProxy');
+    if (cacheProxy && Date.now() < cacheProxy.expiryTime) {
+        return cacheProxy;
+    }
+    return null;
+}
+function _decodeDnsResponse(arrBuff) {
+    const respArr = Array.from(new Uint8Array(arrBuff));
+    let nextIndex = respArr.indexOf(0xc0);
+    const entries = [];
+    while (nextIndex > -1 && nextIndex < respArr.length - 2) {
+        const offset = respArr[nextIndex + 1];
+        if (respArr.length < nextIndex + offset + 1) {
+            break;
+        }
+        const count = respArr[nextIndex + offset];
+        const entry = respArr.slice(nextIndex + offset + 1, nextIndex + offset + count + 1);
+        entries.push(entry.map((e) => String.fromCharCode(e)).join(''));
+        nextIndex = respArr.indexOf(0xc0, nextIndex + offset + count);
+    }
+    return entries;
+}
+function _encodeDomain(domain) {
+    const bin = [
+        0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    ];
+    const entries = domain.split('.');
+    for (const entry of entries) {
+        bin.push(entry.length);
+        for (const char of entry) {
+            bin.push(char.charCodeAt(0));
+        }
+    }
+    bin.push(...[0x00, 0x00, 0x10, 0x00, 0x01]);
+    return Uint8Array.from(bin);
+}
+function _findClosestProxy(txtEntries) {
+    const [proxyList, closestIndex] = _extractProxyListFromTxt(txtEntries);
+    if (proxyList.length === 0) {
+        return null;
+    }
+    return proxyList.length > closestIndex
+        ? proxyList[closestIndex]
+        : proxyList[0];
+}
+function _extractProxyListFromTxt(txtEntries) {
+    let closestDistance = 1440;
+    let closestIndex = 0;
+    const proxyList = [];
+    const localTimezoneOffset = new Date().getTimezoneOffset() + 720;
+    for (const entry of txtEntries) {
+        const [key, value] = entry.split('=');
+        proxyList.push(value);
+        const tzoneOffsetStr = key === null || key === void 0 ? void 0 : key.split('_')[1];
+        const tzoneOffset = parseInt(tzoneOffsetStr);
+        if (tzoneOffset && !Number.isNaN(tzoneOffset)) {
+            const dist = Math.abs(tzoneOffset - localTimezoneOffset);
+            if (dist < closestDistance) {
+                closestIndex = proxyList.length - 1;
+                closestDistance = dist;
+            }
+        }
+    }
+    return [proxyList, closestIndex];
+}
+function _isDefaultUrl(url) {
+    for (const key in NetworkConfig_1.NetworkDefault) {
+        if (url.startsWith(NetworkConfig_1.NetworkDefault[key])) {
+            return true;
+        }
+    }
+    return false;
+}
+function _containsUnresolvedDomain(errorMsg, timedOut) {
+    const lowerErrorMsg = (errorMsg === null || errorMsg === void 0 ? void 0 : errorMsg.toLowerCase()) || '';
+    return (timedOut ||
+        lowerErrorMsg.includes('uncaught exception') ||
+        lowerErrorMsg.includes('failed to fetch') ||
+        lowerErrorMsg.includes('networkerror when attempting to fetch resource'));
+}
+function getEndpoint(urlString) {
+    try {
+        const url = new URL(urlString);
+        const endpoint = url.pathname.substring(1);
+        return endpoint;
+    }
+    catch (error) {
+        return '';
+    }
+}

package/src/SessionID.d.ts

@@ -11,10 +11,10 @@ export type StatsigSession = {
     idleTimeoutID?: SessionTimeoutID;
 };
 export declare const SessionID: {
-    get: (sdkKey: string) => Promise<string>;
+    get: (sdkKey: string) => string;
 };
 export declare const StatsigSession: {
-    get: (sdkKey: string) => Promise<StatsigSession>;
+    get: (sdkKey: string) => StatsigSession;
     overrideInitialSessionID: (override: string, sdkKey: string) => void;
 };
 export {};

package/src/SessionID.js

@@ -1,13 +1,4 @@
 "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.StatsigSession = exports.SessionID = void 0;
 const CacheKey_1 = require("./CacheKey");
@@ -18,49 +9,47 @@ const MAX_SESSION_IDLE_TIME = 30 * 60 * 1000; // 30 minutes
 const MAX_SESSION_AGE = 4 * 60 * 60 * 1000; // 4 hours
 const PROMISE_MAP = {};
 exports.SessionID = {
-    get: (sdkKey) => __awaiter(void 0, void 0, void 0, function* () {
-        return exports.StatsigSession.get(sdkKey).then((x) => x.data.sessionID);
-    }),
+    get: (sdkKey) => {
+        return exports.StatsigSession.get(sdkKey).data.sessionID;
+    },
 };
 exports.StatsigSession = {
-    get: (sdkKey) => __awaiter(void 0, void 0, void 0, function* () {
+    get: (sdkKey) => {
         if (PROMISE_MAP[sdkKey] == null) {
             PROMISE_MAP[sdkKey] = _loadSession(sdkKey);
         }
-        const session = yield PROMISE_MAP[sdkKey];
+        const session = PROMISE_MAP[sdkKey];
         return _bumpSession(session);
-    }),
+    },
     overrideInitialSessionID: (override, sdkKey) => {
         PROMISE_MAP[sdkKey] = _overrideSessionId(override, sdkKey);
     },
 };
 function _loadSession(sdkKey) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let data = yield _loadFromStorage(sdkKey);
-        const now = Date.now();
-        if (!data) {
-            data = {
-                sessionID: (0, UUID_1.getUUID)(),
-                startTime: now,
-                lastUpdate: now,
-            };
-        }
-        return {
-            data,
-            sdkKey,
+    let data = _loadFromStorage(sdkKey);
+    const now = Date.now();
+    if (!data) {
+        data = {
+            sessionID: (0, UUID_1.getUUID)(),
+            startTime: now,
+            lastUpdate: now,
         };
-    });
+    }
+    return {
+        data,
+        sdkKey,
+    };
 }
 function _overrideSessionId(override, sdkKey) {
     const now = Date.now();
-    return Promise.resolve({
+    return {
         data: {
             sessionID: override,
             startTime: now,
             lastUpdate: now,
         },
         sdkKey,
-    });
+    };
 }
 function _bumpSession(session) {
     const now = Date.now();
@@ -98,9 +87,12 @@ function _getSessionIDStorageKey(sdkKey) {
 }
 function _persistToStorage(session, sdkKey) {
     const storageKey = _getSessionIDStorageKey(sdkKey);
-    (0, StorageProvider_1._setObjectInStorage)(storageKey, session).catch(() => {
+    try {
+        (0, StorageProvider_1._setObjectInStorage)(storageKey, session);
+    }
+    catch (e) {
         Log_1.Log.warn('Failed to save SessionID');
-    });
+    }
 }
 function _loadFromStorage(sdkKey) {
     const storageKey = _getSessionIDStorageKey(sdkKey);

package/src/StableID.d.ts

@@ -1,4 +1,4 @@
 export declare const StableID: {
-    get: (sdkKey: string) => Promise<string>;
+    get: (sdkKey: string) => string;
     setOverride: (override: string, sdkKey: string) => void;
 };

package/src/StableID.js

@@ -1,13 +1,4 @@
 "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.StableID = void 0;
 const CacheKey_1 = require("./CacheKey");
@@ -16,21 +7,19 @@ const StorageProvider_1 = require("./StorageProvider");
 const UUID_1 = require("./UUID");
 const PROMISE_MAP = {};
 exports.StableID = {
-    get: (sdkKey) => __awaiter(void 0, void 0, void 0, function* () {
+    get: (sdkKey) => {
         if (PROMISE_MAP[sdkKey] == null) {
-            PROMISE_MAP[sdkKey] = _loadFromStorage(sdkKey).then((stableID) => {
-                if (stableID != null) {
-                    return stableID;
-                }
-                const newStableID = (0, UUID_1.getUUID)();
-                _persistToStorage(newStableID, sdkKey);
-                return newStableID;
-            });
+            let stableID = _loadFromStorage(sdkKey);
+            if (stableID == null) {
+                stableID = (0, UUID_1.getUUID)();
+                _persistToStorage(stableID, sdkKey);
+            }
+            PROMISE_MAP[sdkKey] = stableID;
         }
         return PROMISE_MAP[sdkKey];
-    }),
+    },
     setOverride: (override, sdkKey) => {
-        PROMISE_MAP[sdkKey] = Promise.resolve(override);
+        PROMISE_MAP[sdkKey] = override;
         _persistToStorage(override, sdkKey);
     },
 };
@@ -39,9 +28,12 @@ function _getStableIDStorageKey(sdkKey) {
 }
 function _persistToStorage(stableID, sdkKey) {
     const storageKey = _getStableIDStorageKey(sdkKey);
-    (0, StorageProvider_1._setObjectInStorage)(storageKey, stableID).catch(() => {
+    try {
+        (0, StorageProvider_1._setObjectInStorage)(storageKey, stableID);
+    }
+    catch (e) {
         Log_1.Log.warn('Failed to save StableID');
-    });
+    }
 }
 function _loadFromStorage(sdkKey) {
     const storageKey = _getStableIDStorageKey(sdkKey);

package/src/StatsigMetadata.d.ts

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

package/src/StorageProvider.d.ts

@@ -1,16 +1,15 @@
 export type StorageProvider = {
     _getProviderName: () => string;
-    _getItem: (key: string) => Promise<string | null>;
-    _setItem: (key: string, value: string) => Promise<void>;
-    _removeItem: (key: string) => Promise<void>;
-    _getAllKeys: () => Promise<readonly string[]>;
-    _getItemSync?: (key: string) => string | null;
+    _getItem: (key: string) => string | null;
+    _setItem: (key: string, value: string) => void;
+    _removeItem: (key: string) => void;
+    _getAllKeys: () => readonly string[];
 };
 type StorageProviderManagment = {
     _setProvider: (newProvider: StorageProvider) => void;
     _setDisabled: (isDisabled: boolean) => void;
 };
 export declare const Storage: StorageProvider & StorageProviderManagment;
-export declare function _getObjectFromStorage<T>(key: string): Promise<T | null>;
-export declare function _setObjectInStorage(key: string, obj: unknown): Promise<void>;
+export declare function _getObjectFromStorage<T>(key: string): T | null;
+export declare function _setObjectInStorage(key: string, obj: unknown): void;
 export {};

package/src/StorageProvider.js

@@ -1,26 +1,19 @@
 "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._setObjectInStorage = exports._getObjectFromStorage = exports.Storage = void 0;
 const Log_1 = require("./Log");
 const SafeJs_1 = require("./SafeJs");
 const inMemoryStore = {};
-const _resolve = (input) => Promise.resolve(input);
 const _inMemoryProvider = {
     _getProviderName: () => 'InMemory',
-    _getItemSync: (key) => inMemoryStore[key] ? inMemoryStore[key] : null,
-    _getItem: (key) => _resolve(inMemoryStore[key] ? inMemoryStore[key] : null),
-    _setItem: (key, value) => ((inMemoryStore[key] = value), _resolve()),
-    _removeItem: (key) => (delete inMemoryStore[key], _resolve()),
-    _getAllKeys: () => _resolve(Object.keys(inMemoryStore)),
+    _getItem: (key) => inMemoryStore[key] ? inMemoryStore[key] : null,
+    _setItem: (key, value) => {
+        inMemoryStore[key] = value;
+    },
+    _removeItem: (key) => {
+        delete inMemoryStore[key];
+    },
+    _getAllKeys: () => Object.keys(inMemoryStore),
 };
 let _localStorageProvider = null;
 try {
@@ -30,11 +23,10 @@ try {
         typeof win.localStorage.getItem === 'function') {
         _localStorageProvider = {
             _getProviderName: () => 'LocalStorage',
-            _getItemSync: (key) => win.localStorage.getItem(key),
-            _getItem: (key) => _resolve(win.localStorage.getItem(key)),
-            _setItem: (key, value) => (win.localStorage.setItem(key, value), _resolve()),
-            _removeItem: (key) => (win.localStorage.removeItem(key), _resolve()),
-            _getAllKeys: () => _resolve(Object.keys(win.localStorage)),
+            _getItem: (key) => win.localStorage.getItem(key),
+            _setItem: (key, value) => win.localStorage.setItem(key, value),
+            _removeItem: (key) => win.localStorage.removeItem(key),
+            _getAllKeys: () => Object.keys(win.localStorage),
         };
     }
 }
@@ -57,8 +49,7 @@ function _inMemoryBreaker(get) {
 }
 exports.Storage = {
     _getProviderName: () => _current._getProviderName(),
-    _getItem: (key) => __awaiter(void 0, void 0, void 0, function* () { return _inMemoryBreaker(() => _current._getItem(key)); }),
-    _getItemSync: (key) => _inMemoryBreaker(() => _current._getItemSync ? _current._getItemSync(key) : null),
+    _getItem: (key) => _inMemoryBreaker(() => _current._getItem(key)),
     _setItem: (key, value) => _current._setItem(key, value),
     _removeItem: (key) => _current._removeItem(key),
     _getAllKeys: () => _current._getAllKeys(),
@@ -77,15 +68,11 @@ exports.Storage = {
     },
 };
 function _getObjectFromStorage(key) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const value = yield exports.Storage._getItem(key);
-        return JSON.parse(value !== null && value !== void 0 ? value : 'null');
-    });
+    const value = exports.Storage._getItem(key);
+    return JSON.parse(value !== null && value !== void 0 ? value : 'null');
 }
 exports._getObjectFromStorage = _getObjectFromStorage;
 function _setObjectInStorage(key, obj) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield exports.Storage._setItem(key, JSON.stringify(obj));
-    });
+    exports.Storage._setItem(key, JSON.stringify(obj));
 }
 exports._setObjectInStorage = _setObjectInStorage;

package/src/index.d.ts

@@ -1,5 +1,6 @@
 /** Statsig Global should go first */
 import './$_StatsigGlobal';
+import { Diagnostics } from './Diagnostics';
 import { EventLogger } from './EventLogger';
 import { Log } from './Log';
 import { Storage } from './StorageProvider';
@@ -7,6 +8,7 @@ export * from './$_StatsigGlobal';
 export * from './CacheKey';
 export * from './ClientInterfaces';
 export * from './DataAdapterCore';
+export * from './Diagnostics';
 export * from './DownloadConfigSpecsResponse';
 export * from './ErrorBoundary';
 export * from './EvaluationOptions';
@@ -37,4 +39,4 @@ export * from './TypingUtils';
 export * from './UrlOverrides';
 export * from './UUID';
 export * from './VisibilityObserving';
-export { EventLogger, Storage, Log };
+export { EventLogger, Storage, Log, Diagnostics };

package/src/index.js

@@ -14,9 +14,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Log = exports.Storage = exports.EventLogger = void 0;
+exports.Diagnostics = exports.Log = exports.Storage = exports.EventLogger = void 0;
 /** Statsig Global should go first */
 require("./$_StatsigGlobal");
+const Diagnostics_1 = require("./Diagnostics");
+Object.defineProperty(exports, "Diagnostics", { enumerable: true, get: function () { return Diagnostics_1.Diagnostics; } });
 const EventLogger_1 = require("./EventLogger");
 Object.defineProperty(exports, "EventLogger", { enumerable: true, get: function () { return EventLogger_1.EventLogger; } });
 const Log_1 = require("./Log");
@@ -28,6 +30,7 @@ __exportStar(require("./$_StatsigGlobal"), exports);
 __exportStar(require("./CacheKey"), exports);
 __exportStar(require("./ClientInterfaces"), exports);
 __exportStar(require("./DataAdapterCore"), exports);
+__exportStar(require("./Diagnostics"), exports);
 __exportStar(require("./DownloadConfigSpecsResponse"), exports);
 __exportStar(require("./ErrorBoundary"), exports);
 __exportStar(require("./EvaluationOptions"), exports);