@splitsoftware/splitio-commons 1.3.0 → 1.3.1

package/CHANGES.txt

@@ -1,3 +1,7 @@
+1.3.1 (April 19, 2022)
+ - Bugfixing - Added peer dependencies to avoid issues when requiring some third-party dependencies used by modules of the package (Related to issue https://github.com/splitio/javascript-client/issues/662).
+ - 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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "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/trackers/impressionsTracker.ts

@@ -74,8 +74,8 @@ 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,
+            ip,
+            hostname,
             sdkLanguageVersion: version
           };
 

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,19 @@
+import { ILogger } from '../../logger/types';
+import { Method } 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 | void>;
+    recordException(method: Method): Promise<number | void>;
+}

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

@@ -1,2 +1,18 @@
-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 | void>;
+    recordException(method: Method): Promise<number | 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/trackers/telemetryTracker.d.ts

@@ -0,0 +1,4 @@
+import { TelemetryCacheAsync, TelemetryCacheSync } from '../storages/types';
+import { ISettings } from '../types';
+import { ITelemetryTracker } from './types';
+export declare function telemetryTrackerFactory(settings: ISettings, telemetryCache?: TelemetryCacheAsync | TelemetryCacheSync, now?: () => number): ITelemetryTracker;

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;
     };
     /**