@splitsoftware/splitio-commons 1.3.2-rc.3 → 1.3.2-rc.6

package/src/storages/KeyBuilderSS.ts

@@ -23,10 +23,6 @@ export class KeyBuilderSS extends KeyBuilder {
     return `${this.prefix}.segments.registered`;
   }
 
-  private buildVersionablePrefix() {
-    return `${this.metadata.s}/${this.metadata.n}/${this.metadata.i}`;
-  }
-
   buildImpressionsKey() {
     return `${this.prefix}.impressions`;
   }
@@ -35,6 +31,12 @@ export class KeyBuilderSS extends KeyBuilder {
     return `${this.prefix}.events`;
   }
 
+  searchPatternForSplitKeys() {
+    return `${this.buildSplitKeyPrefix()}*`;
+  }
+
+  /* Telemetry keys */
+
   buildLatencyKey(method: Method, bucket: number) {
     return `${this.prefix}.telemetry.latencies::${this.buildVersionablePrefix()}/${methodNames[method]}/${bucket}`;
   }
@@ -43,8 +45,12 @@ export class KeyBuilderSS extends KeyBuilder {
     return `${this.prefix}.telemetry.exceptions::${this.buildVersionablePrefix()}/${methodNames[method]}`;
   }
 
-  searchPatternForSplitKeys() {
-    return `${this.buildSplitKeyPrefix()}*`;
+  buildInitKey() {
+    return `${this.prefix}.telemetry.init::${this.buildVersionablePrefix()}`;
+  }
+
+  private buildVersionablePrefix() {
+    return `${this.metadata.s}/${this.metadata.n}/${this.metadata.i}`;
   }
 
 }

package/src/storages/inRedis/RedisAdapter.ts

@@ -8,7 +8,7 @@ import { timeout } from '../../utils/promise/timeout';
 const LOG_PREFIX = 'storage:redis-adapter: ';
 
 // If we ever decide to fully wrap every method, there's a Commander.getBuiltinCommands from ioredis.
-const METHODS_TO_PROMISE_WRAP = ['set', 'exec', 'del', 'get', 'keys', 'sadd', 'srem', 'sismember', 'smembers', 'incr', 'rpush', 'pipeline', 'expire', 'mget', 'lrange', 'ltrim'];
+const METHODS_TO_PROMISE_WRAP = ['set', 'exec', 'del', 'get', 'keys', 'sadd', 'srem', 'sismember', 'smembers', 'incr', 'rpush', 'pipeline', 'expire', 'mget', 'lrange', 'ltrim', 'hset'];
 
 // Not part of the settings since it'll vary on each storage. We should be removing storage specific logic from elsewhere.
 const DEFAULT_OPTIONS = {

package/src/storages/inRedis/TelemetryCacheInRedis.ts

@@ -4,6 +4,8 @@ import { KeyBuilderSS } from '../KeyBuilderSS';
 import { ITelemetryCacheAsync } from '../types';
 import { findLatencyIndex } from '../findLatencyIndex';
 import { Redis } from 'ioredis';
+import { getTelemetryConfigStats } from '../../sync/submitters/telemetrySubmitter';
+import { CONSUMER_MODE, STORAGE_REDIS } from '../../utils/constants';
 
 export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
 
@@ -26,4 +28,9 @@ export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
       .catch(() => { /* Handle rejections for telemetry */ });
   }
 
+  recordConfig() {
+    const [key, field] = this.keys.buildInitKey().split('::');
+    const value = JSON.stringify(getTelemetryConfigStats(CONSUMER_MODE, STORAGE_REDIS));
+    return this.redis.hset(key, field, value).catch(() => { /* Handle rejections for telemetry */ });
+  }
 }

package/src/storages/inRedis/index.ts

@@ -26,10 +26,14 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsy
 
     const keys = new KeyBuilderSS(prefix, metadata);
     const redisClient = new RedisAdapter(log, options.options || {});
+    const telemetry = new TelemetryCacheInRedis(log, keys, redisClient);
 
     // subscription to Redis connect event in order to emit SDK_READY event on consumer mode
     redisClient.on('connect', () => {
       onReadyCb();
+
+      // Synchronize config
+      telemetry.recordConfig();
     });
 
     return {
@@ -37,7 +41,7 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsy
       segments: new SegmentsCacheInRedis(log, keys, redisClient),
       impressions: new ImpressionsCacheInRedis(log, keys.buildImpressionsKey(), redisClient, metadata),
       events: new EventsCacheInRedis(log, keys.buildEventsKey(), redisClient, metadata),
-      telemetry: new TelemetryCacheInRedis(log, keys, redisClient),
+      telemetry,
 
       // When using REDIS we should:
       // 1- Disconnect from the storage

package/src/storages/pluggable/index.ts

@@ -39,6 +39,7 @@ function validatePluggableStorageOptions(options: any) {
 function wrapperConnect(wrapper: IPluggableStorageWrapper, onReadyCb: (error?: any) => void) {
   wrapper.connect().then(() => {
     onReadyCb();
+    // At the moment, we don't synchronize config with pluggable storage
   }).catch((e) => {
     onReadyCb(e || new Error('Error connecting wrapper'));
   });
@@ -77,7 +78,7 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
       impressions: isPartialConsumer ? new ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),
       impressionCounts: optimize ? new ImpressionCountsCacheInMemory() : undefined,
       events: isPartialConsumer ? promisifyEventsTrack(new EventsCacheInMemory(eventsQueueSize)) : new EventsCachePluggable(log, keys.buildEventsKey(), wrapper, metadata),
-      // @TODO Not using TelemetryCachePluggable yet, because it is not supported by the Split Synchronizer
+      // @TODO Not using TelemetryCachePluggable yet because it's not supported by the Split Synchronizer, and needs to drop or queue operations while the wrapper is not ready
       // telemetry: isPartialConsumer ? new TelemetryCacheInMemory() : new TelemetryCachePluggable(log, keys, wrapper),
 
       // Disconnect the underlying storage

package/src/sync/submitters/telemetrySubmitter.ts

@@ -1,13 +1,14 @@
 import { ISegmentsCacheSync, ISplitsCacheSync, ITelemetryCacheSync } from '../../storages/types';
 import { submitterFactory, firstPushWindowDecorator } from './submitter';
-import { TelemetryUsageStatsPayload, TelemetryConfigStatsPayload } from './types';
-import { QUEUED, DEDUPED, DROPPED, CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, DEBUG_ENUM, OPTIMIZED_ENUM } from '../../utils/constants';
+import { TelemetryUsageStatsPayload, TelemetryConfigStatsPayload, TelemetryConfigStats } from './types';
+import { QUEUED, DEDUPED, DROPPED, CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, DEBUG_ENUM, OPTIMIZED_ENUM, CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../../utils/constants';
 import { SDK_READY, SDK_READY_FROM_CACHE } from '../../readiness/constants';
-import { ISettings } from '../../types';
+import { ConsentStatus, ISettings, SDKMode } from '../../types';
 import { base } from '../../utils/settingsValidation';
 import { usedKeysMap } from '../../utils/inputValidation/apiKey';
 import { timer } from '../../utils/timeTracker/timer';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+import { objectAssign } from '../../utils/lang/objectAssign';
 
 /**
  * Converts data from telemetry cache into /metrics/usage request payload.
@@ -54,6 +55,12 @@ const IMPRESSIONS_MODE_MAP = {
   [DEBUG]: DEBUG_ENUM
 } as Record<ISettings['sync']['impressionsMode'], (0 | 1)>;
 
+const USER_CONSENT_MAP = {
+  [CONSENT_UNKNOWN]: 1,
+  [CONSENT_GRANTED]: 2,
+  [CONSENT_DECLINED]: 3
+} as Record<ConsentStatus, number>;
+
 function getActiveFactories() {
   return Object.keys(usedKeysMap).length;
 }
@@ -64,6 +71,15 @@ function getRedundantActiveFactories() {
   }, 0);
 }
 
+export function getTelemetryConfigStats(mode: SDKMode, storageType: string): TelemetryConfigStats {
+  return {
+    oM: OPERATION_MODE_MAP[mode], // @ts-ignore lower case of storage type
+    st: storageType.toLowerCase(),
+    aF: getActiveFactories(),
+    rF: getRedundantActiveFactories(),
+  };
+}
+
 /**
  * Converts data from telemetry cache and settings into /metrics/config request payload.
  */
@@ -74,17 +90,17 @@ export function telemetryCacheConfigAdapter(telemetry: ITelemetryCacheSync, sett
 
     state(): TelemetryConfigStatsPayload {
       const { urls, scheduler } = settings;
+      const isClientSide = settings.core.key !== undefined;
 
-      return {
-        oM: OPERATION_MODE_MAP[settings.mode], // @ts-ignore lower case of storage type
-        st: settings.storage.type.toLowerCase(),
+      return objectAssign(getTelemetryConfigStats(settings.mode, settings.storage.type), {
         sE: settings.streamingEnabled,
         rR: {
-          sp: scheduler.featuresRefreshRate,
-          se: scheduler.segmentsRefreshRate,
-          im: scheduler.impressionsRefreshRate,
-          ev: scheduler.eventsPushRate,
-          te: scheduler.telemetryRefreshRate,
+          sp: scheduler.featuresRefreshRate / 1000,
+          se: isClientSide ? undefined : scheduler.segmentsRefreshRate / 1000,
+          ms: isClientSide ? scheduler.segmentsRefreshRate / 1000 : undefined,
+          im: scheduler.impressionsRefreshRate / 1000,
+          ev: scheduler.eventsPushRate / 1000,
+          te: scheduler.telemetryRefreshRate / 1000,
         }, // refreshRates
         uO: {
           s: urls.sdk !== base.urls.sdk,
@@ -98,14 +114,13 @@ export function telemetryCacheConfigAdapter(telemetry: ITelemetryCacheSync, sett
         iM: IMPRESSIONS_MODE_MAP[settings.sync.impressionsMode],
         iL: settings.impressionListener ? true : false,
         hP: false, // @TODO proxy not supported
-        aF: getActiveFactories(),
-        rF: getRedundantActiveFactories(),
         tR: telemetry.getTimeUntilReady() as number,
         tC: telemetry.getTimeUntilReadyFromCache(),
         nR: telemetry.getNonReadyUsage(),
         t: telemetry.popTags(),
         i: settings.integrations && settings.integrations.map(int => int.type),
-      };
+        uC: settings.userConsent ? USER_CONSENT_MAP[settings.userConsent] : 0
+      });
     }
   };
 }
@@ -114,11 +129,11 @@ export function telemetryCacheConfigAdapter(telemetry: ITelemetryCacheSync, sett
  * Submitter that periodically posts telemetry data
  */
 export function telemetrySubmitterFactory(params: ISdkFactoryContextSync) {
-  const { storage: { splits, segments, telemetry } } = params;
-  if (!telemetry) return; // No submitter created if telemetry cache is not defined
+  const { storage: { splits, segments, telemetry }, platform: { now } } = params;
+  if (!telemetry || !now) return; // No submitter created if telemetry cache is not defined
 
-  const { settings, settings: { log, scheduler: { telemetryRefreshRate } }, splitApi, platform: { now }, readiness, sdkReadinessManager } = params;
-  const startTime = timer(now || Date.now);
+  const { settings, settings: { log, scheduler: { telemetryRefreshRate } }, splitApi, readiness, sdkReadinessManager } = params;
+  const startTime = timer(now);
 
   const submitter = firstPushWindowDecorator(
     submitterFactory(log, splitApi.postMetricsUsage, telemetryCacheStatsAdapter(telemetry, splits, segments), telemetryRefreshRate, 'telemetry stats', undefined, 0, true),

package/src/sync/submitters/types.ts

@@ -151,7 +151,8 @@ export type ImpressionsMode = OPTIMIZED_ENUM | DEBUG_ENUM;
 
 export type RefreshRates = {
   sp: number, // splits
-  se: number, // mySegments
+  se?: number, // segments
+  ms?: number, // mySegments
   im: number, // impressions
   ev: number, // events
   te: number, // telemetry
@@ -165,10 +166,17 @@ export type UrlOverrides = {
   t: boolean, // telemetry
 }
 
-// 'metrics/config' JSON request body
-export type TelemetryConfigStatsPayload = {
-  oM?: OperationMode, // operationMode
+// 'telemetry.init' Redis/Pluggable key
+export type TelemetryConfigStats = {
+  oM: OperationMode, // operationMode
   st: 'memory' | 'redis' | 'pluggable' | 'localstorage', // storage
+  aF: number, // activeFactories
+  rF: number, // redundantActiveFactories
+  t?: Array<string>, // tags
+}
+
+// 'metrics/config' JSON request body
+export type TelemetryConfigStatsPayload = TelemetryConfigStats & {
   sE: boolean, // streamingEnabled
   rR: RefreshRates, // refreshRates
   uO: UrlOverrides, // urlOverrides
@@ -177,11 +185,9 @@ export type TelemetryConfigStatsPayload = {
   iM: ImpressionsMode, // impressionsMode
   iL: boolean, // impressionsListenerEnabled
   hP: boolean, // httpProxyDetected
-  aF: number, // activeFactories
-  rF: number, // redundantActiveFactories
   tR: number, // timeUntilSDKReady
   tC?: number, // timeUntilSDKReadyFromCache
   nR: number, // SDKNotReadyUsage
-  t?: Array<string>, // tags
   i?: Array<string>, // integrations
+  uC: number, // userConsent
 }

package/src/trackers/telemetryTracker.ts

@@ -33,7 +33,7 @@ export function telemetryTrackerFactory(
         return (error) => {
           (telemetryCache as ITelemetryCacheSync).recordHttpLatency(operation, httpTime());
           if (error && error.statusCode) (telemetryCache as ITelemetryCacheSync).recordHttpError(operation, error.statusCode);
-          else (telemetryCache as ITelemetryCacheSync).recordSuccessfulSync(operation, now());
+          else (telemetryCache as ITelemetryCacheSync).recordSuccessfulSync(operation, Date.now());
         };
       },
       sessionLength() { // @ts-ignore ITelemetryCacheAsync doesn't implement the method
@@ -44,7 +44,7 @@ export function telemetryTrackerFactory(
           (telemetryCache as ITelemetryCacheSync).recordAuthRejections();
         } else {
           (telemetryCache as ITelemetryCacheSync).recordStreamingEvents({
-            e, d, t: now()
+            e, d, t: Date.now()
           });
           if (e === TOKEN_REFRESH) (telemetryCache as ITelemetryCacheSync).recordTokenRefreshes();
         }

package/src/utils/murmur3/utfx.ts

@@ -8,8 +8,7 @@
 */
 
 export interface utfx {
-  encodeUTF16toUTF8(src: () => number | null, dst: (...args: number[]) => string | undefined): void,
-
+  encodeUTF16toUTF8(src: () => number | null, dst: (...args: number[]) => string | undefined): void
 }
 
 

package/src/utils/timeTracker/now/browser.ts

@@ -1,4 +1,4 @@
-// @TODO migrate to Browser SDK package eventually
+// Can be used on any runtime, since it fallbacks to `Date.now` if `performance.now` is not available
 function nowFactory() {
   // eslint-disable-next-line
   if (typeof performance === 'object' && typeof performance.now === 'function') {

package/src/utils/timeTracker/now/node.ts

@@ -1,7 +1,6 @@
-// @TODO migrate to Node SDK package eventually
 export function now() {
   // eslint-disable-next-line no-undef
   let time = process.hrtime();
 
-  return time[0] * 1e3 + time[1] * 1e-6; // convert it to milis
+  return time[0] * 1e3 + time[1] * 1e-6; // convert it to millis
 }

package/types/sdkFactory/types.d.ts

@@ -10,13 +10,27 @@ import { IImpressionsTracker, IEventTracker, ITelemetryTracker } from '../tracke
 import { SplitIO, ISettings, IEventEmitter } from '../types';
 /**
  * Environment related dependencies.
- * These getters are called a fixed number of times per factory instantiation.
  */
 export interface IPlatform {
-    getOptions?: () => object;
+    /**
+     * If provided, it is used to retrieve the Fetch API for HTTP requests. Otherwise, the global fetch is used.
+     */
     getFetch?: () => (IFetch | undefined);
+    /**
+     * If provided, it is used to pass additional options to fetch calls.
+     */
+    getOptions?: () => object;
+    /**
+     * If provided, it is used to retrieve the EventSource constructor for streaming support.
+     */
     getEventSource?: () => (IEventSourceConstructor | undefined);
+    /**
+     * EventEmitter constructor, like NodeJS.EventEmitter or a polyfill.
+     */
     EventEmitter: new () => IEventEmitter;
+    /**
+     * Function used to track latencies for telemetry.
+     */
     now?: () => number;
 }
 export interface ISdkFactoryContext {

package/types/storages/KeyBuilderSS.d.ts

@@ -5,10 +5,11 @@ export declare class KeyBuilderSS extends KeyBuilder {
     protected readonly metadata: IMetadata;
     constructor(prefix: string, metadata: IMetadata);
     buildRegisteredSegmentsKey(): string;
-    private buildVersionablePrefix;
     buildImpressionsKey(): string;
     buildEventsKey(): string;
+    searchPatternForSplitKeys(): string;
     buildLatencyKey(method: Method, bucket: number): string;
     buildExceptionKey(method: Method): string;
-    searchPatternForSplitKeys(): string;
+    buildInitKey(): string;
+    private buildVersionablePrefix;
 }

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

@@ -16,4 +16,5 @@ export declare class TelemetryCacheInRedis implements ITelemetryCacheAsync {
     constructor(log: ILogger, keys: KeyBuilderSS, redis: Redis);
     recordLatency(method: Method, latencyMs: number): Promise<number | void>;
     recordException(method: Method): Promise<number | void>;
+    recordConfig(): Promise<number | void>;
 }

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

@@ -1,6 +1,6 @@
 import { ISegmentsCacheSync, ISplitsCacheSync, ITelemetryCacheSync } from '../../storages/types';
-import { TelemetryUsageStatsPayload, TelemetryConfigStatsPayload } from './types';
-import { ISettings } from '../../types';
+import { TelemetryUsageStatsPayload, TelemetryConfigStatsPayload, TelemetryConfigStats } from './types';
+import { ISettings, SDKMode } from '../../types';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 /**
  * Converts data from telemetry cache into /metrics/usage request payload.
@@ -10,6 +10,7 @@ export declare function telemetryCacheStatsAdapter(telemetry: ITelemetryCacheSyn
     clear(): void;
     state(): TelemetryUsageStatsPayload;
 };
+export declare function getTelemetryConfigStats(mode: SDKMode, storageType: string): TelemetryConfigStats;
 /**
  * Converts data from telemetry cache and settings into /metrics/config request payload.
  */

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

@@ -134,7 +134,8 @@ export declare type DEBUG_ENUM = 1;
 export declare type ImpressionsMode = OPTIMIZED_ENUM | DEBUG_ENUM;
 export declare type RefreshRates = {
     sp: number;
-    se: number;
+    se?: number;
+    ms?: number;
     im: number;
     ev: number;
     te: number;
@@ -146,9 +147,14 @@ export declare type UrlOverrides = {
     st: boolean;
     t: boolean;
 };
-export declare type TelemetryConfigStatsPayload = {
-    oM?: OperationMode;
+export declare type TelemetryConfigStats = {
+    oM: OperationMode;
     st: 'memory' | 'redis' | 'pluggable' | 'localstorage';
+    aF: number;
+    rF: number;
+    t?: Array<string>;
+};
+export declare type TelemetryConfigStatsPayload = TelemetryConfigStats & {
     sE: boolean;
     rR: RefreshRates;
     uO: UrlOverrides;
@@ -157,11 +163,9 @@ export declare type TelemetryConfigStatsPayload = {
     iM: ImpressionsMode;
     iL: boolean;
     hP: boolean;
-    aF: number;
-    rF: number;
     tR: number;
     tC?: number;
     nR: number;
-    t?: Array<string>;
     i?: Array<string>;
+    uC: number;
 };

package/types/utils/timeTracker/index.d.ts

@@ -1,70 +1 @@
-import { ILogger } from '../../logger/types';
-import { IResponse } from '../../services/types';
-interface MetricsCollector {
-    countException(): void;
-    count(status: number): void;
-    latency(ms: number): void;
-    ready(ms: number): void;
-    getTreatment(ms: number): void;
-    getTreatments(ms: number): void;
-    getTreatmentWithConfig(ms: number): void;
-    getTreatmentsWithConfig(ms: number): void;
-    [method: string]: (ms: number) => void;
-}
-export declare const TrackerAPI: {
-    /**
-     * "Private" method, used to attach count/countException and stop callbacks to a promise.
-     *
-     * @param {ILogger} log - Logger.
-     * @param {Promise} promise - The promise we want to attach the callbacks.
-     * @param {string} task - The name of the task.
-     * @param {number | string} modifier - (optional) The modifier for the task, if any.
-     */
-    __attachToPromise(log: ILogger, promise: Promise<IResponse>, task: string, collector: false | MetricsCollector, modifier?: string | number | undefined): Promise<IResponse>;
-    /**
-     * Starts tracking the time for a given task. All tasks tracked are considered "unique" because
-     * there may be multiple SDK instances tracking a "generic" task, making any task non-generic.
-     *
-     * @param {ILogger} log - Logger.
-     * @param {string} task - The task we are starting.
-     * @param {Object} collectors - The collectors map.
-     * @param {Promise} promise - (optional) The promise we are tracking.
-     * @return {Function | Promise} The stop function for this specific task or the promise received with the callbacks registered.
-     */
-    start(log: ILogger, task: string, collectors?: Record<string, MetricsCollector> | undefined, promise?: Promise<IResponse> | undefined, now?: () => number): Promise<IResponse> | (() => number);
-    /**
-     * Setup the collector for a task that reports metrics.
-     *
-     * @param {string} task - The task name
-     * @param {number | string} taskUniqueId - The unique identifier for this task
-     * @param {Object} collectors - The collectors map.
-     */
-    setCollectorForTask(task: string, taskUniqueId: number | string, collectors: Record<string, MetricsCollector>): void;
-    /**
-     * Stops the tracking of a given task.
-     *
-     * @param {ILogger} log - Logger.
-     * @param {string} task - The task we are starting.
-     * @param {number | string} modifier - (optional) The modifier for that specific task.
-     */
-    stop(log: ILogger, task: string, modifier?: string | number | undefined): number | undefined;
-    /**
-     * The constants shortcut for the task names.
-     */
-    TaskNames: {
-        SDK_READY: string;
-        SDK_GET_TREATMENT: string;
-        SDK_GET_TREATMENTS: string;
-        SDK_GET_TREATMENT_WITH_CONFIG: string;
-        SDK_GET_TREATMENTS_WITH_CONFIG: string;
-        SPLITS_READY: string;
-        SEGMENTS_READY: string;
-        METRICS_PUSH: string;
-        IMPRESSIONS_PUSH: string;
-        EVENTS_PUSH: string;
-        MY_SEGMENTS_FETCH: string;
-        SEGMENTS_FETCH: string;
-        SPLITS_FETCH: string;
-    };
-};
-export {};
+export declare function timeTracker(now: () => number): () => () => number;