@statsig/client-core 0.0.1-beta.1 → 0.0.1-beta.10

package/README.md

@@ -1,5 +1,8 @@
 # Statsig - Core
 
+> [!IMPORTANT]
+> This version of the SDK is still in beta. The non-beta version can be found [here](https://github.com/statsig-io/js-client).
+
 The package that contains all the common logic shared by the various Statsig Javascript packages.
 
-Learn more by visiting: https://docs.statsig.com/client/jsClientSDK
+Learn more by visiting: https://docs.statsig.com/client/javascript-sdk

package/package.json

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

package/src/ClientInterfaces.d.ts

@@ -1,11 +1,14 @@
 import { EvaluationOptions } from './StatsigClientBase';
 import { StatsigClientEventEmitterInterface } from './StatsigClientEventEmitter';
+import { StatsigDataAdapter } from './StatsigDataAdapter';
 import { StatsigEvent } from './StatsigEvent';
 import { DynamicConfig, Experiment, FeatureGate, Layer } from './StatsigTypes';
 import { StatsigUser } from './StatsigUser';
 export interface StatsigClientCommonInterface extends StatsigClientEventEmitterInterface {
-    initialize(): Promise<void>;
+    initializeSync(): void;
+    initializeAsync(): Promise<void>;
     shutdown(): Promise<void>;
+    getDataAdapter(): StatsigDataAdapter;
 }
 export interface OnDeviceEvaluationsInterface extends StatsigClientCommonInterface {
     checkGate(name: string, user: StatsigUser, options: EvaluationOptions): boolean;
@@ -17,7 +20,8 @@ export interface OnDeviceEvaluationsInterface extends StatsigClientCommonInterfa
 }
 export interface PrecomputedEvaluationsInterface extends StatsigClientCommonInterface {
     getCurrentUser(): StatsigUser;
-    updateUser(user: StatsigUser): Promise<void>;
+    updateUserSync(user: StatsigUser): void;
+    updateUserAsync(user: StatsigUser): Promise<void>;
     checkGate(name: string, options: EvaluationOptions): boolean;
     getFeatureGate(name: string, options: EvaluationOptions): FeatureGate;
     getDynamicConfig(name: string, options: EvaluationOptions): DynamicConfig;

package/src/DataAdapterCore.d.ts

@@ -0,0 +1,33 @@
+import { ErrorBoundary } from './ErrorBoundary';
+import { StatsigDataAdapter, StatsigDataAdapterResult } from './StatsigDataAdapter';
+import { StatsigOptionsCommon } from './StatsigOptionsCommon';
+import { StatsigUser } from './StatsigUser';
+type UpdatesAwareObject = {
+    has_updates?: boolean;
+};
+export declare abstract class DataAdapterCore<T extends UpdatesAwareObject> implements StatsigDataAdapter {
+    private _className;
+    private _cacheSuffix;
+    protected _errorBoundary: ErrorBoundary | null;
+    private _sdkKey;
+    private _inMemoryCache;
+    private _lastModifiedStoreKey;
+    protected constructor(_className: string, _cacheSuffix: string);
+    attach(sdkKey: string, _options: StatsigOptionsCommon | null): void;
+    getDataSync(user?: StatsigUser | undefined): StatsigDataAdapterResult | null;
+    getDataAsync(current: StatsigDataAdapterResult | null, user?: StatsigUser): Promise<StatsigDataAdapterResult | null>;
+    /**
+     * (Internal Use Only) - Used by @statsig/react-native-bindings to prime the cache from AsyncStorage
+     * @param {Record<string, StatsigDataAdapterResult>} cache The values to set for _inMemoryCache
+     */
+    _setInMemoryCache(cache: Record<string, StatsigDataAdapterResult>): void;
+    protected abstract _fetchFromNetwork(current: string | null, user?: StatsigUser): Promise<string | null>;
+    private _fetchLatest;
+    protected _getSdkKey(): string;
+    protected _getCacheKey(user?: StatsigUser): string;
+    protected _addToInMemoryCache(cacheKey: string, result: StatsigDataAdapterResult): void;
+    private _loadFromCache;
+    private _writeToCache;
+    private _runLocalStorageCacheEviction;
+}
+export {};

package/src/DataAdapterCore.js

@@ -0,0 +1,241 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataAdapterCore = void 0;
+var ErrorBoundary_1 = require("./ErrorBoundary");
+var Log_1 = require("./Log");
+var Monitoring_1 = require("./Monitoring");
+var StatsigDataAdapter_1 = require("./StatsigDataAdapter");
+var StatsigUser_1 = require("./StatsigUser");
+var StorageProvider_1 = require("./StorageProvider");
+var CACHE_LIMIT = 10;
+var DataAdapterCore = /** @class */ (function () {
+    function DataAdapterCore(_className, _cacheSuffix) {
+        this._className = _className;
+        this._cacheSuffix = _cacheSuffix;
+        this._errorBoundary = null;
+        this._sdkKey = null;
+        this._inMemoryCache = {};
+        this._lastModifiedStoreKey = "statsig.last_modified_time.".concat(_cacheSuffix);
+    }
+    DataAdapterCore.prototype.attach = function (sdkKey, _options) {
+        this._sdkKey = sdkKey;
+        this._errorBoundary = new ErrorBoundary_1.ErrorBoundary(sdkKey);
+        (0, Monitoring_1.monitorClass)(this._errorBoundary, this);
+    };
+    DataAdapterCore.prototype.getDataSync = function (user) {
+        var cacheKey = this._getCacheKey(user);
+        var result = this._inMemoryCache[cacheKey];
+        if (result) {
+            return result;
+        }
+        var cache = this._loadFromCache(cacheKey);
+        if (cache) {
+            this._addToInMemoryCache(cacheKey, cache);
+            return this._inMemoryCache[cacheKey];
+        }
+        return null;
+    };
+    DataAdapterCore.prototype.getDataAsync = function (current, user) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var cache, latest, cacheKey;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        cache = current !== null && current !== void 0 ? current : this.getDataSync(user);
+                        return [4 /*yield*/, this._fetchLatest((_a = cache === null || cache === void 0 ? void 0 : cache.data) !== null && _a !== void 0 ? _a : null, user)];
+                    case 1:
+                        latest = _b.sent();
+                        cacheKey = this._getCacheKey(user);
+                        if (latest) {
+                            this._addToInMemoryCache(cacheKey, latest);
+                        }
+                        if (!((latest === null || latest === void 0 ? void 0 : latest.source) === 'Network' ||
+                            (latest === null || latest === void 0 ? void 0 : latest.source) === 'NetworkNotModified')) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this._writeToCache(cacheKey, latest)];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3: return [2 /*return*/, latest];
+                }
+            });
+        });
+    };
+    /**
+     * (Internal Use Only) - Used by @statsig/react-native-bindings to prime the cache from AsyncStorage
+     * @param {Record<string, StatsigDataAdapterResult>} cache The values to set for _inMemoryCache
+     */
+    DataAdapterCore.prototype._setInMemoryCache = function (cache) {
+        this._inMemoryCache = cache;
+    };
+    DataAdapterCore.prototype._fetchLatest = function (current, user) {
+        return __awaiter(this, void 0, void 0, function () {
+            var latest, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._fetchFromNetwork(current, user)];
+                    case 1:
+                        latest = _a.sent();
+                        if (!latest) {
+                            Log_1.Log.debug('No response returned for latest value');
+                            return [2 /*return*/, null];
+                        }
+                        try {
+                            response = JSON.parse(latest);
+                            if (current && response.has_updates === false) {
+                                return [2 /*return*/, {
+                                        source: 'NetworkNotModified',
+                                        data: current,
+                                        receivedAt: Date.now(),
+                                    }];
+                            }
+                            if (response.has_updates !== true) {
+                                return [2 /*return*/, null];
+                            }
+                            return [2 /*return*/, { source: 'Network', data: latest, receivedAt: Date.now() }];
+                        }
+                        catch (_b) {
+                            Log_1.Log.debug('Failure while attempting to persist latest value');
+                        }
+                        return [2 /*return*/, null];
+                }
+            });
+        });
+    };
+    DataAdapterCore.prototype._getSdkKey = function () {
+        if (this._sdkKey) {
+            return this._sdkKey;
+        }
+        Log_1.Log.error("".concat(this._className, " is not attached to a Client"));
+        return '';
+    };
+    DataAdapterCore.prototype._getCacheKey = function (user) {
+        var key = (0, StatsigUser_1.getUserStorageKey)(this._getSdkKey(), user);
+        return "".concat(StatsigDataAdapter_1.DataAdapterCachePrefix, ".").concat(this._cacheSuffix, ".").concat(key);
+    };
+    DataAdapterCore.prototype._addToInMemoryCache = function (cacheKey, result) {
+        var entries = Object.entries(this._inMemoryCache);
+        if (entries.length < CACHE_LIMIT) {
+            this._inMemoryCache[cacheKey] = result;
+            return;
+        }
+        var oldest = entries.reduce(function (acc, curr) {
+            return curr[1] < acc[1] ? curr : acc;
+        })[0];
+        delete this._inMemoryCache[oldest];
+        this._inMemoryCache[cacheKey] = result;
+    };
+    DataAdapterCore.prototype._loadFromCache = function (cacheKey) {
+        if (typeof window === 'undefined' || !window.localStorage) {
+            return null;
+        }
+        var cache = window.localStorage.getItem(cacheKey);
+        if (cache == null) {
+            return null;
+        }
+        try {
+            var result = JSON.parse(cache);
+            return __assign(__assign({}, result), { source: 'Cache' });
+        }
+        catch (e) {
+            Log_1.Log.error('Failed to parse cached result');
+            return null;
+        }
+    };
+    DataAdapterCore.prototype._writeToCache = function (cacheKey, result) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, StorageProvider_1.Storage.setItem(cacheKey, JSON.stringify(result))];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this._runLocalStorageCacheEviction(cacheKey)];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DataAdapterCore.prototype._runLocalStorageCacheEviction = function (cacheKey) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var lastModifiedTimeMap, entries, oldest;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, (0, StorageProvider_1.getObjectFromStorage)(this._lastModifiedStoreKey)];
+                    case 1:
+                        lastModifiedTimeMap = (_a = (_b.sent())) !== null && _a !== void 0 ? _a : {};
+                        lastModifiedTimeMap[cacheKey] = Date.now();
+                        entries = Object.entries(lastModifiedTimeMap);
+                        if (!(entries.length <= CACHE_LIMIT)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, (0, StorageProvider_1.setObjectInStorage)(this._lastModifiedStoreKey, lastModifiedTimeMap)];
+                    case 2:
+                        _b.sent();
+                        return [2 /*return*/];
+                    case 3:
+                        oldest = entries.reduce(function (acc, current) {
+                            return current[1] < acc[1] ? current : acc;
+                        });
+                        delete lastModifiedTimeMap[oldest[0]];
+                        return [4 /*yield*/, StorageProvider_1.Storage.removeItem(oldest[0])];
+                    case 4:
+                        _b.sent();
+                        return [4 /*yield*/, (0, StorageProvider_1.setObjectInStorage)(this._lastModifiedStoreKey, lastModifiedTimeMap)];
+                    case 5:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return DataAdapterCore;
+}());
+exports.DataAdapterCore = DataAdapterCore;

package/src/ErrorBoundary.d.ts

@@ -5,5 +5,6 @@ export declare class ErrorBoundary {
     private _seen;
     constructor(_sdkKey: string);
     capture(tag: string, task: () => unknown, emitter?: StatsigClientEmitEventFunc): unknown;
+    logError(tag: string, error: unknown): void;
     private _onError;
 }

package/src/ErrorBoundary.js

@@ -70,6 +70,9 @@ var ErrorBoundary = /** @class */ (function () {
             return null;
         }
     };
+    ErrorBoundary.prototype.logError = function (tag, error) {
+        this._onError(tag, error);
+    };
     ErrorBoundary.prototype._onError = function (tag, error, emitter) {
         var _this = this;
         try {

package/src/EventLogger.d.ts

@@ -13,18 +13,24 @@ export declare class EventLogger {
     private _lastExposureMap;
     private _maxQueueSize;
     private _failedLogs;
+    private _hasRunQuickFlush;
+    private _creationTime;
     constructor(_sdkKey: string, _emitter: StatsigClientEmitEventFunc, _network: NetworkCore, _options: StatsigOptionsCommon | null);
     enqueue(event: StatsigEventInternal): void;
     reset(): void;
     onVisibilityChanged(visibility: Visibility): void;
     shutdown(): Promise<void>;
+    /**
+     * We 'Quick Flush' following the very first event enqueued
+     * within the quick flush window
+     */
+    private _quickFlushIfNeeded;
     private _shouldLogEvent;
     private _flushAndForget;
     private _flush;
     private _sendEvents;
     private _sendEventsViaPost;
     private _sendEventsViaBeacon;
-    private _isBeaconSupported;
     private _saveFailedLogsToStorage;
     private _retryFailedLogs;
     private _getStorageKey;

package/src/EventLogger.js

@@ -60,6 +60,7 @@ var MAX_DEDUPER_KEYS = 1000;
 var DEDUPER_WINDOW_DURATION_MS = 60000;
 var MAX_FAILED_LOGS = 500;
 var DEFAULT_API = 'https://api.statsig.com/v1';
+var QUICK_FLUSH_WINDOW_MS = 200;
 var EventLogger = /** @class */ (function () {
     function EventLogger(_sdkKey, _emitter, _network, _options) {
         var _this = this;
@@ -70,6 +71,8 @@ var EventLogger = /** @class */ (function () {
         this._options = _options;
         this._queue = [];
         this._lastExposureMap = {};
+        this._hasRunQuickFlush = false;
+        this._creationTime = Date.now();
         this._maxQueueSize = (_a = _options === null || _options === void 0 ? void 0 : _options.loggingBufferMaxSize) !== null && _a !== void 0 ? _a : DEFAULT_QUEUE_SIZE;
         var flushInterval = (_b = _options === null || _options === void 0 ? void 0 : _options.loggingIntervalMs) !== null && _b !== void 0 ? _b : DEFAULT_FLUSH_INTERVAL_MS;
         this._flushTimer = setInterval(function () { return _this._flushAndForget(); }, flushInterval);
@@ -87,6 +90,7 @@ var EventLogger = /** @class */ (function () {
         }
         var _a = StatsigMetadata_1.StatsigMetadataProvider.get(), sdkType = _a.sdkType, sdkVersion = _a.sdkVersion;
         this._queue.push(__assign(__assign({}, event), { statsigMetadata: { sdkType: sdkType, sdkVersion: sdkVersion } }));
+        this._quickFlushIfNeeded();
         if (this._queue.length > this._maxQueueSize) {
             this._flushAndForget();
         }
@@ -116,6 +120,21 @@ var EventLogger = /** @class */ (function () {
             });
         });
     };
+    /**
+     * We 'Quick Flush' following the very first event enqueued
+     * within the quick flush window
+     */
+    EventLogger.prototype._quickFlushIfNeeded = function () {
+        var _this = this;
+        if (this._hasRunQuickFlush) {
+            return;
+        }
+        this._hasRunQuickFlush = true;
+        if (Date.now() - this._creationTime > QUICK_FLUSH_WINDOW_MS) {
+            return;
+        }
+        setTimeout(function () { return _this._flushAndForget(); }, QUICK_FLUSH_WINDOW_MS);
+    };
     EventLogger.prototype._shouldLogEvent = function (event) {
         var _a, _b, _c, _d;
         if (!(0, StatsigEvent_1.isExposureEvent)(event)) {
@@ -170,17 +189,19 @@ var EventLogger = /** @class */ (function () {
             return __generator(this, function (_e) {
                 switch (_e.label) {
                     case 0:
-                        _e.trys.push([0, 4, , 5]);
+                        _e.trys.push([0, 5, , 6]);
                         isInForeground = VisibilityChangeObserver_1.VisibilityChangeObserver.isCurrentlyVisible();
                         api = (_b = (_a = this._options) === null || _a === void 0 ? void 0 : _a.api) !== null && _b !== void 0 ? _b : DEFAULT_API;
-                        if (!(!isInForeground && this._isBeaconSupported())) return [3 /*break*/, 1];
-                        _c = this._sendEventsViaBeacon(api, events);
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, this._sendEventsViaPost(api, events)];
-                    case 2:
+                        if (!(!isInForeground && this._network.isBeaconSupported())) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this._sendEventsViaBeacon(api, events)];
+                    case 1:
                         _c = _e.sent();
-                        _e.label = 3;
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, this._sendEventsViaPost(api, events)];
                     case 3:
+                        _c = _e.sent();
+                        _e.label = 4;
+                    case 4:
                         response = _c;
                         if (response.success) {
                             this._emitter({
@@ -191,12 +212,12 @@ var EventLogger = /** @class */ (function () {
                         else {
                             this._saveFailedLogsToStorage(events);
                         }
-                        return [3 /*break*/, 5];
-                    case 4:
+                        return [3 /*break*/, 6];
+                    case 5:
                         _d = _e.sent();
                         Log_1.Log.warn('Failed to flush events.');
-                        return [3 /*break*/, 5];
-                    case 5: return [2 /*return*/];
+                        return [3 /*break*/, 6];
+                    case 6: return [2 /*return*/];
                 }
             });
         });
@@ -213,15 +234,15 @@ var EventLogger = /** @class */ (function () {
                             },
                             url: "".concat(api, "/rgstr"),
                             retries: 3,
-                            headers: {
-                                'Content-Type': 'application/json',
-                                'STATSIG-EVENT-COUNT': String(events.length),
+                            params: {
+                                // ec = Event Count
+                                ec: String(events.length),
                             },
                         })];
                     case 1:
                         result = _a.sent();
-                        if (result) {
-                            return [2 /*return*/, JSON.parse(result)];
+                        if (result === null || result === void 0 ? void 0 : result.body) {
+                            return [2 /*return*/, JSON.parse(result.body)];
                         }
                         return [2 /*return*/, { success: false }];
                 }
@@ -229,19 +250,24 @@ var EventLogger = /** @class */ (function () {
         });
     };
     EventLogger.prototype._sendEventsViaBeacon = function (api, events) {
-        return {
-            success: this._network.beacon({
-                sdkKey: this._sdkKey,
-                data: {
-                    events: events,
-                },
-                url: "".concat(api, "/log_event_beacon"),
-            }),
-        };
-    };
-    EventLogger.prototype._isBeaconSupported = function () {
-        return (typeof navigator !== 'undefined' &&
-            typeof (navigator === null || navigator === void 0 ? void 0 : navigator.sendBeacon) === 'function');
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = {};
+                        return [4 /*yield*/, this._network.beacon({
+                                sdkKey: this._sdkKey,
+                                data: {
+                                    events: events,
+                                },
+                                url: "".concat(api, "/log_event_beacon"),
+                            })];
+                    case 1: return [2 /*return*/, (_a.success = _b.sent(),
+                            _a)];
+                }
+            });
+        });
     };
     EventLogger.prototype._saveFailedLogsToStorage = function (events) {
         var _a;

package/src/Monitoring.d.ts

@@ -1,3 +1,2 @@
 import { ErrorBoundary } from './ErrorBoundary';
-export declare function monitorClass<T extends new (...args: any[]) => any>(errorBoundary: ErrorBoundary, target: T, instance: unknown): void;
-export declare function monitorFunction<T>(errorBoundary: ErrorBoundary, tag: string, func: () => T, instance: unknown): T;
+export declare function monitorClass(errorBoundary: ErrorBoundary, instance: object): void;

package/src/Monitoring.js

@@ -1,13 +1,57 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.monitorFunction = exports.monitorClass = void 0;
+exports.monitorClass = void 0;
 var Diagnostics_1 = require("./Diagnostics");
 var StatsigClientBase_1 = require("./StatsigClientBase");
-function monitorClass(errorBoundary, target, instance) {
-    var methods = Object.getOwnPropertyNames(target.prototype);
+function monitorClass(errorBoundary, instance) {
+    try {
+        _monitorClassImpl(errorBoundary, instance);
+    }
+    catch (error) {
+        errorBoundary.logError('monitorClass', error);
+    }
+}
+exports.monitorClass = monitorClass;
+function _monitorFunction(errorBoundary, tag, func, instance) {
+    var client = instance instanceof StatsigClientBase_1.StatsigClientBase ? instance['emit'] : undefined;
+    return errorBoundary.capture(tag, function () { return (0, Diagnostics_1.captureDiagnostics)(tag, function () { return func.apply(instance); }); }, client);
+}
+function _getProtoSafe(instance) {
+    if (typeof instance === 'object') {
+        var proto = Object.getPrototypeOf(instance);
+        return proto && typeof proto === 'object'
+            ? proto
+            : null;
+    }
+    return null;
+}
+function _getAllInstanceMethodNames(instance) {
+    var names = new Set();
+    var proto = _getProtoSafe(instance);
+    while (proto && proto !== Object.prototype) {
+        Object.getOwnPropertyNames(proto)
+            .filter(function (prop) { return typeof (proto === null || proto === void 0 ? void 0 : proto[prop]) === 'function'; })
+            .forEach(function (name) { return names.add(name); });
+        proto = Object.getPrototypeOf(proto);
+    }
+    return Array.from(names);
+}
+function _getAllStaticMethodNames(instance) {
+    var names = new Set();
+    var proto = _getProtoSafe(instance);
+    Object.getOwnPropertyNames((proto === null || proto === void 0 ? void 0 : proto.constructor) || {})
+        .filter(function (prop) {
+        var _a;
+        return typeof ((_a = proto === null || proto === void 0 ? void 0 : proto.constructor) === null || _a === void 0 ? void 0 : _a[prop]) === 'function';
+    })
+        .forEach(function (name) { return names.add(name); });
+    return Array.from(names);
+}
+function _monitorClassImpl(errorBoundary, instance) {
+    var _a;
     var obj = instance;
     var _loop_1 = function (method) {
-        if (method === 'constructor' || typeof obj[method] !== 'function') {
+        if (method === 'constructor') {
             return "continue";
         }
         var original = obj[method];
@@ -17,17 +61,26 @@ function monitorClass(errorBoundary, target, instance) {
             for (var _i = 0; _i < arguments.length; _i++) {
                 args[_i] = arguments[_i];
             }
-            return monitorFunction(errorBoundary, method, function () { return original.apply(_this, args); }, instance);
+            return _monitorFunction(errorBoundary, method, function () { return original.apply(_this, args); }, instance);
         };
     };
-    for (var _i = 0, methods_1 = methods; _i < methods_1.length; _i++) {
-        var method = methods_1[_i];
+    for (var _i = 0, _b = _getAllInstanceMethodNames(obj); _i < _b.length; _i++) {
+        var method = _b[_i];
         _loop_1(method);
     }
+    var _loop_2 = function (method) {
+        var original = (_a = obj === null || obj === void 0 ? void 0 : obj.constructor) === null || _a === void 0 ? void 0 : _a[method];
+        (obj === null || obj === void 0 ? void 0 : obj.constructor)[method] =
+            function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                return _monitorFunction(errorBoundary, "".concat(obj.constructor.name, ".").concat(method), function () { return original.apply(obj.constructor, args); }, instance);
+            };
+    };
+    for (var _c = 0, _d = _getAllStaticMethodNames(obj); _c < _d.length; _c++) {
+        var method = _d[_c];
+        _loop_2(method);
+    }
 }
-exports.monitorClass = monitorClass;
-function monitorFunction(errorBoundary, tag, func, instance) {
-    var client = instance instanceof StatsigClientBase_1.StatsigClientBase ? instance['emit'] : undefined;
-    return errorBoundary.capture(tag, function () { return (0, Diagnostics_1.captureDiagnostics)(tag, function () { return func.apply(instance); }); }, client);
-}
-exports.monitorFunction = monitorFunction;

package/src/NetworkCore.d.ts

@@ -1,22 +1,31 @@
+import { StatsigClientEmitEventFunc } from './StatsigClientBase';
 import { StatsigOptionsCommon } from './StatsigOptionsCommon';
 type RequestArgs = {
     sdkKey: string;
     url: string;
     timeoutMs?: number;
     retries?: number;
+    params?: Record<string, string>;
     headers?: Record<string, string>;
 };
 type RequestArgsWithData = RequestArgs & {
     data: Record<string, unknown>;
 };
+type NetworkResponse = {
+    body: string | null;
+    code: number;
+};
 export declare class NetworkCore {
     private _options;
+    private _emitter?;
     private readonly _timeout;
-    constructor(_options: StatsigOptionsCommon | null);
-    post(args: RequestArgsWithData): Promise<string | null>;
-    get(args: RequestArgs): Promise<string | null>;
-    beacon(args: RequestArgsWithData): boolean;
+    constructor(_options: StatsigOptionsCommon | null, _emitter?: StatsigClientEmitEventFunc | undefined);
+    post(args: RequestArgsWithData): Promise<NetworkResponse | null>;
+    get(args: RequestArgs): Promise<NetworkResponse | null>;
+    isBeaconSupported(): boolean;
+    beacon(args: RequestArgsWithData): Promise<boolean>;
     private _sendRequest;
     private _getPopulatedURL;
+    private _getPopulatedBody;
 }
 export {};