@splitsoftware/splitio-commons 1.3.0 → 1.3.1-rc.0

package/CHANGES.txt

@@ -1,3 +1,6 @@
+1.3.1 (TBD)
+ - Bugfixing - Updated `ready` method to rejects the promise with an Error object instead of a string value (Related to issue https://github.com/splitio/javascript-client/issues/654).
+
 1.3.0 (April 6, 2022)
  - Added user consent feature to allow delaying or disabling the data tracking from SDK until user consent is explicitly granted or declined. Read more in our docs.
  - Added `scheduler.impressionsQueueSize` property to SDK configuration to limit the amount of impressions tracked in memory. Read more in our docs.

package/cjs/readiness/sdkReadinessManager.js

@@ -44,7 +44,7 @@ function sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, internalRea
     });
     // default onRejected handler, that just logs the error, if ready promise doesn't have one.
     function defaultOnRejected(err) {
-        log.error(err);
+        log.error(err && err.message);
     }
     function generateReadyPromise() {
         var promise = (0, wrapper_1.promiseWrapper)(new Promise(function (resolve, reject) {
@@ -54,7 +54,9 @@ function sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, internalRea
                     log.warn(constants_2.CLIENT_NO_LISTENER);
                 resolve();
             });
-            readinessManager.gate.once(constants_1.SDK_READY_TIMED_OUT, reject);
+            readinessManager.gate.once(constants_1.SDK_READY_TIMED_OUT, function (message) {
+                reject(new Error(message));
+            });
         }), defaultOnRejected);
         return promise;
     }
@@ -97,7 +99,7 @@ function sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, internalRea
             ready: function () {
                 if (readinessManager.hasTimedout()) {
                     if (!readinessManager.isReady()) {
-                        return (0, wrapper_1.promiseWrapper)(Promise.reject('Split SDK has emitted SDK_READY_TIMED_OUT event.'), defaultOnRejected);
+                        return (0, wrapper_1.promiseWrapper)(Promise.reject(new Error('Split SDK has emitted SDK_READY_TIMED_OUT event.')), defaultOnRejected);
                     }
                     else {
                         return Promise.resolve();

package/cjs/services/splitHttpClient.js

@@ -12,25 +12,26 @@ var messageNoFetch = 'Global fetch API is not available.';
  * @param fetch optional http client to use instead of the global Fetch (for environments where Fetch API is not available such as Node)
  */
 function splitHttpClientFactory(settings, getFetch, getOptions) {
-    var log = settings.log, authorizationKey = settings.core.authorizationKey, version = settings.version, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname;
+    var log = settings.log;
     var options = getOptions && getOptions();
     var fetch = getFetch && getFetch();
     // if fetch is not available, log Error
     if (!fetch)
         log.error(constants_1.ERROR_CLIENT_CANNOT_GET_READY, [messageNoFetch]);
-    var headers = {
-        'Accept': 'application/json',
-        'Content-Type': 'application/json',
-        'Authorization': "Bearer " + authorizationKey,
-        'SplitSDKVersion': version
-    };
-    if (ip)
-        headers['SplitSDKMachineIP'] = ip;
-    if (hostname)
-        headers['SplitSDKMachineName'] = hostname;
     return function httpClient(url, reqOpts, logErrorsAsInfo) {
         if (reqOpts === void 0) { reqOpts = {}; }
         if (logErrorsAsInfo === void 0) { logErrorsAsInfo = false; }
+        var authorizationKey = settings.core.authorizationKey, version = settings.version, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname;
+        var headers = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': "Bearer " + authorizationKey,
+            'SplitSDKVersion': version
+        };
+        if (ip)
+            headers['SplitSDKMachineIP'] = ip;
+        if (hostname)
+            headers['SplitSDKMachineName'] = hostname;
         var request = (0, objectAssign_1.objectAssign)({
             headers: reqOpts.headers ? (0, objectAssign_1.objectAssign)({}, headers, reqOpts.headers) : headers,
             method: reqOpts.method || 'GET',

package/cjs/trackers/impressionsTracker.js

@@ -21,7 +21,7 @@ function impressionsTrackerFactory(settings, impressionsCache, integrationsManag
 observer, 
 // if countsCache is provided, it implies `isOptimized` flag (i.e., if impressions should be deduped or not)
 countsCache) {
-    var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version;
+    var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname;
     return {
         track: function (impressions, attributes) {
             if (settings.userConsent === constants_2.CONSENT_DECLINED)
@@ -62,7 +62,7 @@ countsCache) {
                         attributes: attributes,
                         ip: ip,
                         hostname: hostname,
-                        sdkLanguageVersion: version
+                        sdkLanguageVersion: settings.version
                     };
                     // Wrap in a timeout because we don't want it to be blocking.
                     setTimeout(function () {

package/esm/readiness/sdkReadinessManager.js

@@ -41,7 +41,7 @@ export function sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, inte
     });
     // default onRejected handler, that just logs the error, if ready promise doesn't have one.
     function defaultOnRejected(err) {
-        log.error(err);
+        log.error(err && err.message);
     }
     function generateReadyPromise() {
         var promise = promiseWrapper(new Promise(function (resolve, reject) {
@@ -51,7 +51,9 @@ export function sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, inte
                     log.warn(CLIENT_NO_LISTENER);
                 resolve();
             });
-            readinessManager.gate.once(SDK_READY_TIMED_OUT, reject);
+            readinessManager.gate.once(SDK_READY_TIMED_OUT, function (message) {
+                reject(new Error(message));
+            });
         }), defaultOnRejected);
         return promise;
     }
@@ -94,7 +96,7 @@ export function sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, inte
             ready: function () {
                 if (readinessManager.hasTimedout()) {
                     if (!readinessManager.isReady()) {
-                        return promiseWrapper(Promise.reject('Split SDK has emitted SDK_READY_TIMED_OUT event.'), defaultOnRejected);
+                        return promiseWrapper(Promise.reject(new Error('Split SDK has emitted SDK_READY_TIMED_OUT event.')), defaultOnRejected);
                     }
                     else {
                         return Promise.resolve();

package/esm/services/splitHttpClient.js

@@ -9,25 +9,26 @@ var messageNoFetch = 'Global fetch API is not available.';
  * @param fetch optional http client to use instead of the global Fetch (for environments where Fetch API is not available such as Node)
  */
 export function splitHttpClientFactory(settings, getFetch, getOptions) {
-    var log = settings.log, authorizationKey = settings.core.authorizationKey, version = settings.version, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname;
+    var log = settings.log;
     var options = getOptions && getOptions();
     var fetch = getFetch && getFetch();
     // if fetch is not available, log Error
     if (!fetch)
         log.error(ERROR_CLIENT_CANNOT_GET_READY, [messageNoFetch]);
-    var headers = {
-        'Accept': 'application/json',
-        'Content-Type': 'application/json',
-        'Authorization': "Bearer " + authorizationKey,
-        'SplitSDKVersion': version
-    };
-    if (ip)
-        headers['SplitSDKMachineIP'] = ip;
-    if (hostname)
-        headers['SplitSDKMachineName'] = hostname;
     return function httpClient(url, reqOpts, logErrorsAsInfo) {
         if (reqOpts === void 0) { reqOpts = {}; }
         if (logErrorsAsInfo === void 0) { logErrorsAsInfo = false; }
+        var authorizationKey = settings.core.authorizationKey, version = settings.version, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname;
+        var headers = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': "Bearer " + authorizationKey,
+            'SplitSDKVersion': version
+        };
+        if (ip)
+            headers['SplitSDKMachineIP'] = ip;
+        if (hostname)
+            headers['SplitSDKMachineName'] = hostname;
         var request = objectAssign({
             headers: reqOpts.headers ? objectAssign({}, headers, reqOpts.headers) : headers,
             method: reqOpts.method || 'GET',

package/esm/trackers/impressionsTracker.js

@@ -18,7 +18,7 @@ export function impressionsTrackerFactory(settings, impressionsCache, integratio
 observer, 
 // if countsCache is provided, it implies `isOptimized` flag (i.e., if impressions should be deduped or not)
 countsCache) {
-    var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version;
+    var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname;
     return {
         track: function (impressions, attributes) {
             if (settings.userConsent === CONSENT_DECLINED)
@@ -59,7 +59,7 @@ countsCache) {
                         attributes: attributes,
                         ip: ip,
                         hostname: hostname,
-                        sdkLanguageVersion: version
+                        sdkLanguageVersion: settings.version
                     };
                     // Wrap in a timeout because we don't want it to be blocking.
                     setTimeout(function () {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.3.0",
+  "version": "1.3.1-rc.0",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -46,6 +46,18 @@
   "dependencies": {
     "tslib": "^2.3.1"
   },
+  "peerDependencies": {
+    "js-yaml": "^3.13.1",
+    "ioredis": "^4.28.0"
+  },
+  "peerDependenciesMeta": {
+    "js-yaml": {
+      "optional": true
+    },
+    "ioredis": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@types/google.analytics": "0.0.40",
     "@types/ioredis": "^4.28.0",
@@ -62,7 +74,7 @@
     "ioredis": "^4.28.0",
     "jest": "^27.2.3",
     "jest-localstorage-mock": "^2.4.3",
-    "js-yaml": "^3.14.0",
+    "js-yaml": "^3.13.1",
     "lodash": "^4.17.21",
     "node-fetch": "^2.6.7",
     "redis-server": "1.2.2",

package/src/readiness/sdkReadinessManager.ts

@@ -51,7 +51,7 @@ export function sdkReadinessManagerFactory(
 
   // default onRejected handler, that just logs the error, if ready promise doesn't have one.
   function defaultOnRejected(err: any) {
-    log.error(err);
+    log.error(err && err.message);
   }
 
   function generateReadyPromise() {
@@ -62,7 +62,9 @@ export function sdkReadinessManagerFactory(
         if (readyCbCount === internalReadyCbCount && !promise.hasOnFulfilled()) log.warn(CLIENT_NO_LISTENER);
         resolve();
       });
-      readinessManager.gate.once(SDK_READY_TIMED_OUT, reject);
+      readinessManager.gate.once(SDK_READY_TIMED_OUT, (message: string) => {
+        reject(new Error(message));
+      });
     }), defaultOnRejected);
 
     return promise;
@@ -106,10 +108,10 @@ export function sdkReadinessManagerFactory(
          * @function ready
          * @returns {Promise<void>}
          */
-        ready: () => {
+        ready() {
           if (readinessManager.hasTimedout()) {
             if (!readinessManager.isReady()) {
-              return promiseWrapper(Promise.reject('Split SDK has emitted SDK_READY_TIMED_OUT event.'), defaultOnRejected);
+              return promiseWrapper(Promise.reject(new Error('Split SDK has emitted SDK_READY_TIMED_OUT event.')), defaultOnRejected);
             } else {
               return Promise.resolve();
             }
@@ -118,7 +120,7 @@ export function sdkReadinessManagerFactory(
         },
 
         // Expose status for internal purposes only. Not considered part of the public API, and might be updated eventually.
-        __getStatus: () => {
+        __getStatus() {
           return {
             isReady: readinessManager.isReady(),
             isReadyFromCache: readinessManager.isReadyFromCache(),

package/src/services/splitHttpClient.ts

@@ -14,24 +14,26 @@ const messageNoFetch = 'Global fetch API is not available.';
  */
 export function splitHttpClientFactory(settings: Pick<ISettings, 'log' | 'version' | 'runtime' | 'core'>, getFetch?: () => (IFetch | undefined), getOptions?: () => object): ISplitHttpClient {
 
-  const { log, core: { authorizationKey }, version, runtime: { ip, hostname } } = settings;
+  const log = settings.log;
   const options = getOptions && getOptions();
   const fetch = getFetch && getFetch();
 
   // if fetch is not available, log Error
   if (!fetch) log.error(ERROR_CLIENT_CANNOT_GET_READY, [messageNoFetch]);
 
-  const headers: Record<string, string> = {
-    'Accept': 'application/json',
-    'Content-Type': 'application/json',
-    'Authorization': `Bearer ${authorizationKey}`,
-    'SplitSDKVersion': version
-  };
+  return function httpClient(url: string, reqOpts: IRequestOptions = {}, logErrorsAsInfo: boolean = false): Promise<IResponse> {
 
-  if (ip) headers['SplitSDKMachineIP'] = ip;
-  if (hostname) headers['SplitSDKMachineName'] = hostname;
+    const { core: { authorizationKey }, version, runtime: { ip, hostname } } = settings;
 
-  return function httpClient(url: string, reqOpts: IRequestOptions = {}, logErrorsAsInfo: boolean = false): Promise<IResponse> {
+    const headers: Record<string, string> = {
+      'Accept': 'application/json',
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${authorizationKey}`,
+      'SplitSDKVersion': version
+    };
+
+    if (ip) headers['SplitSDKMachineIP'] = ip;
+    if (hostname) headers['SplitSDKMachineName'] = hostname;
 
     const request = objectAssign({
       headers: reqOpts.headers ? objectAssign({}, headers, reqOpts.headers) : headers,

package/src/trackers/impressionsTracker.ts

@@ -28,7 +28,7 @@ export function impressionsTrackerFactory(
   countsCache?: IImpressionCountsCacheSync
 ): IImpressionsTracker {
 
-  const { log, impressionListener, runtime: { ip, hostname }, version } = settings;
+  const { log, impressionListener, runtime: { ip, hostname } } = settings;
 
   return {
     track(impressions: ImpressionDTO[], attributes?: SplitIO.Attributes) {
@@ -74,9 +74,9 @@ export function impressionsTrackerFactory(
             // copy of impression, to avoid unexpected behaviour if modified by integrations or impressionListener
             impression: objectAssign({}, impressions[i]),
             attributes,
-            ip: ip as string,
-            hostname: hostname as string,
-            sdkLanguageVersion: version
+            ip,
+            hostname,
+            sdkLanguageVersion: settings.version
           };
 
           // Wrap in a timeout because we don't want it to be blocking.

package/src/types.ts

@@ -535,8 +535,8 @@ export namespace SplitIO {
   export type ImpressionData = {
     impression: ImpressionDTO,
     attributes?: SplitIO.Attributes,
-    ip: string,
-    hostname: string,
+    ip: string| false,
+    hostname: string | false,
     sdkLanguageVersion: string
   };
   /**

package/types/storages/inMemory/TelemetryCacheInMemory.d.ts

@@ -1,4 +1,4 @@
-import { ImpressionDataType, EventDataType, StreamingEvent, Method, OperationType } from '../../sync/submitters/types';
+import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies, StreamingEvent, Method, OperationType, MethodExceptions, MethodLatencies } from '../../sync/submitters/types';
 import { TelemetryCacheSync } from '../types';
 export declare class TelemetryCacheInMemory implements TelemetryCacheSync {
     private timeUntilReady?;
@@ -17,16 +17,14 @@ export declare class TelemetryCacheInMemory implements TelemetryCacheSync {
     getEventStats(type: EventDataType): number;
     recordEventStats(type: EventDataType, count: number): void;
     private lastSync;
-    getLastSynchronization(): Record<OperationType, number | undefined>;
+    getLastSynchronization(): LastSync;
     recordSuccessfulSync(resource: OperationType, timeMs: number): void;
     private httpErrors;
-    popHttpErrors(): Record<OperationType, {
-        [statusCode: string]: number;
-    }>;
-    recordSyncError(resource: OperationType, status: number): void;
+    popHttpErrors(): HttpErrors;
+    recordHttpError(resource: OperationType, status: number): void;
     private httpLatencies;
-    popHttpLatencies(): Record<OperationType, number[]>;
-    recordSyncLatency(resource: OperationType, latencyMs: number): void;
+    popHttpLatencies(): HttpLatencies;
+    recordHttpLatency(resource: OperationType, latencyMs: number): void;
     private authRejections;
     popAuthRejections(): number;
     recordAuthRejections(): void;
@@ -43,9 +41,9 @@ export declare class TelemetryCacheInMemory implements TelemetryCacheSync {
     getSessionLength(): number | undefined;
     recordSessionLength(ms: number): void;
     private exceptions;
-    popExceptions(): Record<Method, number>;
+    popExceptions(): MethodExceptions;
     recordException(method: Method): void;
     private latencies;
-    popLatencies(): Record<Method, number[]>;
+    popLatencies(): MethodLatencies;
     recordLatency(method: Method, latencyMs: number): void;
 }

package/types/storages/inRedis/TelemetryCacheInRedis.d.ts

@@ -0,0 +1,21 @@
+import { ILogger } from '../../logger/types';
+import { Method, MethodExceptions, MethodLatencies } from '../../sync/submitters/types';
+import { KeyBuilderSS } from '../KeyBuilderSS';
+import { TelemetryCacheAsync } from '../types';
+import { Redis } from 'ioredis';
+export declare class TelemetryCacheInRedis implements TelemetryCacheAsync {
+    private readonly log;
+    private readonly keys;
+    private readonly redis;
+    /**
+     * Create a Telemetry cache that uses a storage wrapper.
+     * @param log  Logger instance.
+     * @param keys  Key builder.
+     * @param redis  Redis client.
+     */
+    constructor(log: ILogger, keys: KeyBuilderSS, redis: Redis);
+    recordLatency(method: Method, latencyMs: number): Promise<number>;
+    recordException(method: Method): Promise<number>;
+    popExceptions(): Promise<MethodExceptions>;
+    popLatencies(): Promise<MethodLatencies>;
+}

package/types/storages/pluggable/TelemetryCachePluggable.d.ts

@@ -1,2 +1,20 @@
-export declare class TelemetryCachePluggable {
+import { ILogger } from '../../logger/types';
+import { Method } from '../../sync/submitters/types';
+import { KeyBuilderSS } from '../KeyBuilderSS';
+import { IPluggableStorageWrapper, TelemetryCacheAsync } from '../types';
+export declare class TelemetryCachePluggable implements TelemetryCacheAsync {
+    private readonly log;
+    private readonly keys;
+    private readonly wrapper;
+    /**
+     * Create a Telemetry cache that uses a storage wrapper.
+     * @param log  Logger instance.
+     * @param keys  Key builder.
+     * @param wrapper  Adapted wrapper storage.
+     */
+    constructor(log: ILogger, keys: KeyBuilderSS, wrapper: IPluggableStorageWrapper);
+    recordLatency(method: Method, latencyMs: number): Promise<number>;
+    recordException(method: Method): Promise<number>;
+    popExceptions(): void;
+    popLatencies(): void;
 }

package/types/sync/submitters/telemetrySyncTask.d.ts

@@ -1,17 +1,27 @@
 import { ISyncTask, ITimeTracker } from '../types';
-import { IPostMetricsUsage } from '../../services/types';
+import { ISplitApi } from '../../services/types';
 import { IStorageSync, TelemetryCacheSync } from '../../storages/types';
-import { TelemetryStatsPayload } from './types';
-import { ILogger } from '../../logger/types';
+import { TelemetryUsageStatsPayload, TelemetryConfigStatsPayload } from './types';
+import { IReadinessManager } from '../../readiness/types';
+import { ISettings } from '../../types';
 /**
  * Converts `impressions` data from cache into request payload.
  */
-export declare function telemetryCacheAdapter(telemetryCache: TelemetryCacheSync, storage: IStorageSync): {
+export declare function telemetryCacheStatsAdapter({ splits, segments, telemetry }: IStorageSync & {
+    telemetry: TelemetryCacheSync;
+}): {
     isEmpty(): boolean;
     clear(): void;
-    state(): TelemetryStatsPayload;
+    state(): TelemetryUsageStatsPayload;
+};
+export declare function telemetryCacheConfigAdapter(settings: ISettings, telemetryCache: TelemetryCacheSync): {
+    isEmpty(): boolean;
+    clear(): void;
+    state(): TelemetryConfigStatsPayload;
 };
 /**
  * Sync task that periodically posts impressions data
  */
-export declare function telemetrySyncTaskFactory(log: ILogger, postMetricsUsage: IPostMetricsUsage, telemetryCache: TelemetryCacheSync, telemetryRefreshRate: number, latencyTracker: ITimeTracker, storage: IStorageSync): ISyncTask;
+export declare function telemetrySyncTaskFactory(settings: ISettings, { postMetricsUsage, postMetricsConfig }: ISplitApi, storage: IStorageSync & {
+    telemetry: TelemetryCacheSync;
+}, telemetryRefreshRate: number, readiness: IReadinessManager, latencyTracker?: ITimeTracker): ISyncTask;

package/types/types.d.ts

@@ -526,8 +526,8 @@ export declare namespace SplitIO {
     type ImpressionData = {
         impression: ImpressionDTO;
         attributes?: SplitIO.Attributes;
-        ip: string;
-        hostname: string;
+        ip: string | false;
+        hostname: string | false;
         sdkLanguageVersion: string;
     };
     /**