@statsig/client-core 3.32.3 → 3.32.4

package/package.json

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

package/src/ErrorBoundary.d.ts

@@ -11,7 +11,7 @@ export declare class ErrorBoundary {
     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, retries: number): void;
+    logEventRequestFailure(count: number, reason: string, flushType: string, statusCode: number, retries: number, failurePath?: string): void;
     getLastSeenErrorAndReset(): Error | null;
     attachErrorIfNoneExists(error: unknown): void;
     private _capture;

package/src/ErrorBoundary.js

@@ -56,7 +56,7 @@ class ErrorBoundary {
         }
         this._onError(`statsig::log_event_dropped_event_count`, new Error(reason), true, extra);
     }
-    logEventRequestFailure(count, reason, flushType, statusCode, retries) {
+    logEventRequestFailure(count, reason, flushType, statusCode, retries, failurePath) {
         const extra = {
             eventCount: String(count),
             flushType: flushType,
@@ -64,6 +64,9 @@ class ErrorBoundary {
             reason: reason,
             retries: String(retries),
         };
+        if (failurePath) {
+            extra['failurePath'] = failurePath;
+        }
         this._onError(`statsig::log_event_failed`, new Error(reason), true, extra);
     }
     getLastSeenErrorAndReset() {

package/src/EventSender.d.ts

@@ -3,6 +3,11 @@ import { NetworkCore } from './NetworkCore';
 import { StatsigClientEmitEventFunc } from './StatsigClientBase';
 import { LogEventCompressionMode, NetworkConfigCommon, StatsigOptionsCommon } from './StatsigOptionsCommon';
 import { UrlConfiguration } from './UrlConfiguration';
+type EventSendResult = {
+    success: boolean;
+    statusCode: number;
+    failurePath?: string;
+};
 export declare class EventSender {
     private _network;
     private _sdkKey;
@@ -11,11 +16,9 @@ export declare class EventSender {
     private _emitter;
     constructor(sdkKey: string, network: NetworkCore, emitter: StatsigClientEmitEventFunc, logEventUrlConfig: UrlConfiguration, options: StatsigOptionsCommon<NetworkConfigCommon> | null);
     setLogEventCompressionMode(mode: LogEventCompressionMode): void;
-    sendBatch(batch: EventBatch): Promise<{
-        success: boolean;
-        statusCode: number;
-    }>;
+    sendBatch(batch: EventBatch): Promise<EventSendResult>;
     private _sendEventsViaPost;
     private _sendEventsViaBeacon;
     private _getRequestData;
 }
+export {};

package/src/EventSender.js

@@ -12,6 +12,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventSender = void 0;
 const Log_1 = require("./Log");
 const NetworkConfig_1 = require("./NetworkConfig");
+const SDKType_1 = require("./SDKType");
+const StatsigMetadata_1 = require("./StatsigMetadata");
 const VisibilityObserving_1 = require("./VisibilityObserving");
 class EventSender {
     constructor(sdkKey, network, emitter, logEventUrlConfig, options) {
@@ -26,47 +28,75 @@ class EventSender {
     }
     sendBatch(batch) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
+            var _a, _b, _c;
+            let failurePath = 'event_sender_unexpected_exception';
+            const transportFailure = {};
             try {
                 const isClosing = (0, VisibilityObserving_1._isUnloading)();
                 const shouldUseBeacon = isClosing &&
                     this._network.isBeaconSupported() &&
                     ((_b = (_a = this._options) === null || _a === void 0 ? void 0 : _a.networkConfig) === null || _b === void 0 ? void 0 : _b.networkOverrideFunc) == null;
+                failurePath = 'event_sender_pre_logs_flushed_emitter_exception';
                 this._emitter({
                     name: 'pre_logs_flushed',
                     events: batch.events,
                 });
+                failurePath = shouldUseBeacon
+                    ? 'event_sender_unexpected_exception'
+                    : 'event_sender_post_exception';
                 const response = shouldUseBeacon
-                    ? this._sendEventsViaBeacon(batch)
-                    : yield this._sendEventsViaPost(batch);
+                    ? this._sendEventsViaBeacon(batch, transportFailure)
+                    : yield this._sendEventsViaPost(batch, transportFailure);
                 if (response.success) {
+                    failurePath = 'event_sender_logs_flushed_emitter_exception';
                     this._emitter({
                         name: 'logs_flushed',
                         events: batch.events,
                     });
                     return response;
                 }
-                return { success: false, statusCode: response.statusCode };
+                return {
+                    success: false,
+                    statusCode: response.statusCode,
+                    failurePath: response.failurePath,
+                };
             }
             catch (error) {
                 Log_1.Log.warn('Failed to send batch:', error);
-                return { success: false, statusCode: -1 };
+                return {
+                    success: false,
+                    statusCode: -1,
+                    failurePath: (_c = transportFailure.path) !== null && _c !== void 0 ? _c : failurePath,
+                };
             }
         });
     }
-    _sendEventsViaPost(batch) {
+    _sendEventsViaPost(batch, failureInfo) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const result = yield this._network.post(this._getRequestData(batch));
+            var _a, _b;
+            const result = yield this._network.post(this._getRequestData(batch), failureInfo);
             const code = (_a = result === null || result === void 0 ? void 0 : result.code) !== null && _a !== void 0 ? _a : -1;
+            if (code === -1) {
+                return {
+                    success: false,
+                    statusCode: -1,
+                    failurePath: (_b = failureInfo.path) !== null && _b !== void 0 ? _b : (result === undefined
+                        ? 'event_sender_post_returned_undefined'
+                        : 'event_sender_post_returned_null'),
+                };
+            }
             return { success: code >= 200 && code < 300, statusCode: code };
         });
     }
-    _sendEventsViaBeacon(batch) {
-        const success = this._network.beacon(this._getRequestData(batch));
+    _sendEventsViaBeacon(batch, failureInfo) {
+        var _a;
+        const success = this._network.beacon(this._getRequestData(batch), failureInfo);
         return {
             success,
             statusCode: success ? 200 : -1,
+            failurePath: success
+                ? undefined
+                : (_a = failureInfo.path) !== null && _a !== void 0 ? _a : 'beacon_send_false',
         };
     }
     _getRequestData(batch) {
@@ -85,6 +115,8 @@ class EventSender {
             headers: {
                 'statsig-event-count': String(batch.events.length),
                 'statsig-retry-count': String(batch.attempts),
+                'statsig-sdk-type': SDKType_1.SDKType._get(this._sdkKey),
+                'statsig-sdk-version': StatsigMetadata_1.SDK_VERSION,
             },
             credentials: 'same-origin',
         };

package/src/FlushCoordinator.js

@@ -254,7 +254,7 @@ class FlushCoordinator {
                 return true;
             }
             this._flushInterval.adjustForFailure();
-            this._handleFailure(batch, flushType, result.statusCode);
+            this._handleFailure(batch, flushType, result.statusCode, result.failurePath);
             return false;
         });
     }
@@ -283,7 +283,7 @@ class FlushCoordinator {
         const allEvents = this._pendingEvents.takeAll();
         return this._batchQueue.createBatches(allEvents);
     }
-    _handleFailure(batch, flushType, statusCode) {
+    _handleFailure(batch, flushType, statusCode, failurePath) {
         if (flushType === FlushTypes_1.FlushType.Shutdown) {
             Log_1.Log.warn(`${flushType} flush failed during shutdown. ` +
                 `${batch.events.length} event(s) will be saved to storage for retry in next session.`);
@@ -293,13 +293,13 @@ class FlushCoordinator {
         if (!NetworkCore_1.RETRYABLE_CODES.has(statusCode)) {
             Log_1.Log.warn(`${flushType} flush failed after ${batch.attempts} attempt(s). ` +
                 `${batch.events.length} event(s) will be dropped. Non-retryable error: ${statusCode}`);
-            this._errorBoundary.logEventRequestFailure(batch.events.length, `non-retryable error`, flushType, statusCode, batch.attempts);
+            this._errorBoundary.logEventRequestFailure(batch.events.length, `non-retryable error`, flushType, statusCode, batch.attempts, failurePath);
             return;
         }
         if (batch.attempts >= EventRetryConstants_1.EventRetryConstants.MAX_RETRY_ATTEMPTS) {
             Log_1.Log.warn(`${flushType} flush failed after ${batch.attempts} attempt(s). ` +
                 `${batch.events.length} event(s) will be dropped.`);
-            this._errorBoundary.logEventRequestFailure(batch.events.length, `max retry attempts exceeded`, flushType, statusCode, batch.attempts);
+            this._errorBoundary.logEventRequestFailure(batch.events.length, `max retry attempts exceeded`, flushType, statusCode, batch.attempts, failurePath);
             return;
         }
         batch.incrementAttempts();

package/src/NetworkCore.d.ts

@@ -24,6 +24,9 @@ type DataFlags = {
 export type RequestArgsWithData = Flatten<RequestArgs & {
     data: Record<string, unknown>;
 } & DataFlags>;
+export type RequestFailureInfo = {
+    path?: string;
+};
 type BeaconRequestArgs = Pick<RequestArgsWithData, 'data' | 'sdkKey' | 'urlConfig' | 'params' | 'isCompressable' | 'attempt'>;
 type NetworkResponse = {
     body: string | null;
@@ -43,8 +46,8 @@ export declare class NetworkCore {
     setErrorBoundary(errorBoundary: ErrorBoundary): void;
     isBeaconSupported(): boolean;
     getLastUsedInitUrlAndReset(): string | null;
-    beacon(args: BeaconRequestArgs): boolean;
-    post(args: RequestArgsWithData): Promise<NetworkResponse | null>;
+    beacon(args: BeaconRequestArgs, failureInfo?: RequestFailureInfo): boolean;
+    post(args: RequestArgsWithData, failureInfo?: RequestFailureInfo): Promise<NetworkResponse | null>;
     get(args: RequestArgs): Promise<NetworkResponse | null>;
     private _sendRequest;
     private _getLogEventCompressionMode;

package/src/NetworkCore.js

@@ -73,40 +73,66 @@ class NetworkCore {
         this._lastUsedInitUrl = null;
         return tempUrl;
     }
-    beacon(args) {
+    beacon(args, failureInfo) {
         if (!_ensureValidSdkKey(args)) {
+            if (failureInfo) {
+                failureInfo.path = 'beacon_invalid_sdk_key';
+            }
             return false;
         }
         const argsInternal = this._getInternalRequestArgs('POST', args);
         const url = this._getPopulatedURL(argsInternal);
         const nav = navigator;
-        return nav.sendBeacon.bind(nav)(url, argsInternal.body);
+        try {
+            const success = nav.sendBeacon.bind(nav)(url, argsInternal.body);
+            if (!success) {
+                if (failureInfo) {
+                    failureInfo.path = 'beacon_send_false';
+                }
+            }
+            return success;
+        }
+        catch (error) {
+            if (failureInfo) {
+                failureInfo.path = 'beacon_send_exception';
+            }
+            throw error;
+        }
     }
-    post(args) {
+    post(args, failureInfo) {
         return __awaiter(this, void 0, void 0, function* () {
             const argsInternal = this._getInternalRequestArgs('POST', args);
             this._tryEncodeBody(argsInternal);
             yield this._tryToCompressBody(argsInternal);
-            return this._sendRequest(argsInternal);
+            return this._sendRequest(argsInternal, failureInfo);
         });
     }
     get(args) {
         const argsInternal = this._getInternalRequestArgs('GET', args);
         return this._sendRequest(argsInternal);
     }
-    _sendRequest(args) {
+    _sendRequest(args, failureInfo) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c, _d;
             if (!_ensureValidSdkKey(args)) {
+                if (failureInfo) {
+                    failureInfo.path = 'network_invalid_sdk_key';
+                }
                 return null;
             }
             if (this._netConfig.preventAllNetworkTraffic) {
+                if (failureInfo) {
+                    failureInfo.path = 'network_prevent_all_network_traffic';
+                }
                 return null;
             }
             const { method, body, retries, attempt } = args;
             const endpoint = args.urlConfig.endpoint;
             if (this._isRateLimited(endpoint)) {
                 Log_1.Log.warn(`Request to ${endpoint} was blocked because you are making requests too frequently.`);
+                if (failureInfo) {
+                    failureInfo.path = 'network_rate_limited';
+                }
                 return null;
             }
             const currentAttempt = attempt !== null && attempt !== void 0 ? attempt : 1;
@@ -179,10 +205,17 @@ class NetworkCore {
                             code: response.status,
                         };
                     }
+                    if (response == null) {
+                        if (failureInfo) {
+                            failureInfo.path = timedOut
+                                ? 'network_request_timed_out_no_response'
+                                : 'network_request_exception_no_response';
+                        }
+                    }
                     return null;
                 }
                 yield _exponentialBackoff(currentAttempt);
-                return this._sendRequest(Object.assign(Object.assign({}, args), { retries, attempt: currentAttempt + 1 }));
+                return this._sendRequest(Object.assign(Object.assign({}, args), { retries, attempt: currentAttempt + 1 }), failureInfo);
             }
         });
     }

package/src/StatsigMetadata.d.ts

@@ -1,4 +1,4 @@
-export declare const SDK_VERSION = "3.32.3";
+export declare const SDK_VERSION = "3.32.4";
 export type StatsigMetadata = {
     readonly [key: string]: string | undefined | null;
     readonly appVersion?: string;

package/src/StatsigMetadata.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StatsigMetadataProvider = exports.SDK_VERSION = void 0;
-exports.SDK_VERSION = '3.32.3';
+exports.SDK_VERSION = '3.32.4';
 let metadata = {
     sdkVersion: exports.SDK_VERSION,
     sdkType: 'js-mono', // js-mono is overwritten by Precomp and OnDevice clients