@splitsoftware/splitio-commons 1.3.2-rc.1 → 1.3.2-rc.4

package/esm/sync/submitters/telemetrySubmitter.js

@@ -1,10 +1,11 @@
-var _a, _b;
+var _a, _b, _c;
 import { submitterFactory, firstPushWindowDecorator } from './submitter';
-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 { 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 { base } from '../../utils/settingsValidation';
 import { usedKeysMap } from '../../utils/inputValidation/apiKey';
 import { timer } from '../../utils/timeTracker/timer';
+import { objectAssign } from '../../utils/lang/objectAssign';
 /**
  * Converts data from telemetry cache into /metrics/usage request payload.
  */
@@ -46,6 +47,11 @@ var IMPRESSIONS_MODE_MAP = (_b = {},
     _b[OPTIMIZED] = OPTIMIZED_ENUM,
     _b[DEBUG] = DEBUG_ENUM,
     _b);
+var USER_CONSENT_MAP = (_c = {},
+    _c[CONSENT_UNKNOWN] = 1,
+    _c[CONSENT_GRANTED] = 2,
+    _c[CONSENT_DECLINED] = 3,
+    _c);
 function getActiveFactories() {
     return Object.keys(usedKeysMap).length;
 }
@@ -54,6 +60,14 @@ function getRedundantActiveFactories() {
         return acum + usedKeysMap[apiKey] - 1;
     }, 0);
 }
+export function getTelemetryConfigStats(mode, storageType) {
+    return {
+        oM: OPERATION_MODE_MAP[mode],
+        st: storageType.toLowerCase(),
+        aF: getActiveFactories(),
+        rF: getRedundantActiveFactories(),
+    };
+}
 /**
  * Converts data from telemetry cache and settings into /metrics/config request payload.
  */
@@ -63,9 +77,7 @@ export function telemetryCacheConfigAdapter(telemetry, settings) {
         clear: function () { },
         state: function () {
             var urls = settings.urls, scheduler = settings.scheduler;
-            return {
-                oM: OPERATION_MODE_MAP[settings.mode],
-                st: settings.storage.type.toLowerCase(),
+            return objectAssign(getTelemetryConfigStats(settings.mode, settings.storage.type), {
                 sE: settings.streamingEnabled,
                 rR: {
                     sp: scheduler.featuresRefreshRate,
@@ -86,14 +98,13 @@ export function telemetryCacheConfigAdapter(telemetry, settings) {
                 iM: IMPRESSIONS_MODE_MAP[settings.sync.impressionsMode],
                 iL: settings.impressionListener ? true : false,
                 hP: false,
-                aF: getActiveFactories(),
-                rF: getRedundantActiveFactories(),
                 tR: telemetry.getTimeUntilReady(),
                 tC: telemetry.getTimeUntilReadyFromCache(),
                 nR: telemetry.getNonReadyUsage(),
                 t: telemetry.popTags(),
                 i: settings.integrations && settings.integrations.map(function (int) { return int.type; }),
-            };
+                uC: settings.userConsent ? USER_CONSENT_MAP[settings.userConsent] : 0
+            });
         }
     };
 }
@@ -104,12 +115,13 @@ export function telemetrySubmitterFactory(params) {
     var _a = params.storage, splits = _a.splits, segments = _a.segments, telemetry = _a.telemetry;
     if (!telemetry)
         return; // No submitter created if telemetry cache is not defined
-    var settings = params.settings, _b = params.settings, log = _b.log, telemetryRefreshRate = _b.scheduler.telemetryRefreshRate, splitApi = params.splitApi, now = params.platform.now, readiness = params.readiness;
+    var settings = params.settings, _b = params.settings, log = _b.log, telemetryRefreshRate = _b.scheduler.telemetryRefreshRate, splitApi = params.splitApi, now = params.platform.now, readiness = params.readiness, sdkReadinessManager = params.sdkReadinessManager;
     var startTime = timer(now || Date.now);
     var submitter = firstPushWindowDecorator(submitterFactory(log, splitApi.postMetricsUsage, telemetryCacheStatsAdapter(telemetry, splits, segments), telemetryRefreshRate, 'telemetry stats', undefined, 0, true), telemetryRefreshRate);
     readiness.gate.once(SDK_READY_FROM_CACHE, function () {
         telemetry.recordTimeUntilReadyFromCache(startTime());
     });
+    sdkReadinessManager.incInternalReadyCbCount();
     readiness.gate.once(SDK_READY, function () {
         telemetry.recordTimeUntilReady(startTime());
         // Post config data when the SDK is ready and if the telemetry submitter was started

package/esm/utils/settingsValidation/index.js

@@ -1,7 +1,7 @@
 import { merge } from '../lang';
 import { mode } from './mode';
 import { validateSplitFilters } from './splitFilters';
-import { STANDALONE_MODE, OPTIMIZED, LOCALHOST_MODE } from '../constants';
+import { STANDALONE_MODE, OPTIMIZED, LOCALHOST_MODE, DEBUG } from '../constants';
 import { validImpressionsMode } from './impressionsMode';
 import { validateKey } from '../inputValidation/key';
 import { validateTrafficType } from '../inputValidation/trafficType';
@@ -29,8 +29,8 @@ export var base = {
         segmentsRefreshRate: 60,
         // publish telemetry stats each 3600 secs (1 hour)
         telemetryRefreshRate: 3600,
-        // publish evaluations each 60 sec
-        impressionsRefreshRate: 60,
+        // publish evaluations each 300 sec (default value for OPTIMIZED impressions mode)
+        impressionsRefreshRate: 300,
         // fetch offline changes each 15 sec
         offlineRefreshRate: 15,
         // publish events every 60 seconds after the first flush
@@ -52,7 +52,7 @@ export var base = {
         // Streaming Server
         streaming: 'https://streaming.split.io',
         // Telemetry Server
-        telemetry: 'https://telemetry.split.io',
+        telemetry: 'https://telemetry.split.io/api',
     },
     // Defines which kind of storage we should instanciate.
     storage: undefined,
@@ -93,6 +93,8 @@ export function settingsValidation(config, validationParams) {
     // First thing to validate, since other validators might use the logger.
     var log = logger(withDefaults); // @ts-ignore, modify readonly prop
     withDefaults.log = log;
+    // ensure a valid impressionsMode
+    withDefaults.sync.impressionsMode = validImpressionsMode(log, withDefaults.sync.impressionsMode);
     function validateMinValue(paramName, actualValue, minValue) {
         if (actualValue >= minValue)
             return actualValue;
@@ -104,10 +106,20 @@ export function settingsValidation(config, validationParams) {
     var scheduler = withDefaults.scheduler, startup = withDefaults.startup;
     scheduler.featuresRefreshRate = fromSecondsToMillis(scheduler.featuresRefreshRate);
     scheduler.segmentsRefreshRate = fromSecondsToMillis(scheduler.segmentsRefreshRate);
-    scheduler.impressionsRefreshRate = fromSecondsToMillis(scheduler.impressionsRefreshRate);
     scheduler.offlineRefreshRate = fromSecondsToMillis(scheduler.offlineRefreshRate);
     scheduler.eventsPushRate = fromSecondsToMillis(scheduler.eventsPushRate);
     scheduler.telemetryRefreshRate = fromSecondsToMillis(validateMinValue('telemetryRefreshRate', scheduler.telemetryRefreshRate, 60));
+    if (scheduler.impressionsRefreshRate !== base.scheduler.impressionsRefreshRate) {
+        // Validate impressionsRefreshRate defined by user
+        scheduler.impressionsRefreshRate = validateMinValue('impressionsRefreshRate', scheduler.impressionsRefreshRate, withDefaults.sync.impressionsMode === DEBUG ? 1 : 60 // Min is 1 sec for DEBUG and 60 secs for OPTIMIZED
+        );
+    }
+    else {
+        // Default impressionsRefreshRate for DEBUG mode is 60 secs
+        if (withDefaults.sync.impressionsMode === DEBUG)
+            scheduler.impressionsRefreshRate = 60;
+    }
+    scheduler.impressionsRefreshRate = fromSecondsToMillis(scheduler.impressionsRefreshRate);
     // Log deprecation for old telemetry param
     if (scheduler.metricsRefreshRate)
         log.warn('`metricsRefreshRate` will be deprecated soon. For configuring telemetry rates, update `telemetryRefreshRate` value in configs');
@@ -163,8 +175,6 @@ export function settingsValidation(config, validationParams) {
     var splitFiltersValidation = validateSplitFilters(log, withDefaults.sync.splitFilters, withDefaults.mode);
     withDefaults.sync.splitFilters = splitFiltersValidation.validFilters;
     withDefaults.sync.__splitFiltersValidation = splitFiltersValidation;
-    // ensure a valid impressionsMode
-    withDefaults.sync.impressionsMode = validImpressionsMode(log, withDefaults.sync.impressionsMode);
     // ensure a valid user consent value
     // @ts-ignore, modify readonly prop
     withDefaults.userConsent = consent(withDefaults);

package/esm/utils/settingsValidation/url.js

@@ -1,4 +1,4 @@
-var telemetryEndpointMatcher = /^\/metrics\/(config|usage)/;
+var telemetryEndpointMatcher = /^\/v1\/metrics\/(config|usage)/;
 var eventsEndpointMatcher = /^\/(testImpressions|metrics|events)/;
 var authEndpointMatcher = /^\/v2\/auth/;
 var streamingEndpointMatcher = /^\/(sse|event-stream)/;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.3.2-rc.1",
+  "version": "1.3.2-rc.4",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/listeners/browser.ts

@@ -12,6 +12,7 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { CLEANUP_REGISTERING, CLEANUP_DEREGISTERING } from '../logger/constants';
 import { ISyncManager } from '../sync/types';
 import { isConsentGranted } from '../consent';
+import { telemetryCacheStatsAdapter } from '../sync/submitters/telemetrySubmitter';
 
 // 'unload' event is used instead of 'beforeunload', since 'unload' is not a cancelable event, so no other listeners can stop the event from occurring.
 const UNLOAD_DOM_EVENT = 'unload';
@@ -77,7 +78,11 @@ export class BrowserSignalListener implements ISignalListener {
       this._flushData(eventsUrl + '/testImpressions/beacon', this.storage.impressions, this.serviceApi.postTestImpressionsBulk, this.fromImpressionsCollector, extraMetadata);
       this._flushData(eventsUrl + '/events/beacon', this.storage.events, this.serviceApi.postEventsBulk);
       if (this.storage.impressionCounts) this._flushData(eventsUrl + '/testImpressions/count/beacon', this.storage.impressionCounts, this.serviceApi.postTestImpressionsCount, fromImpressionCountsCollector);
-      // No beacon endpoint for `/metrics/usage`
+      if (this.storage.telemetry) {
+        const telemetryUrl = this.settings.urls.telemetry;
+        const telemetryCacheAdapter = telemetryCacheStatsAdapter(this.storage.telemetry, this.storage.splits, this.storage.segments);
+        this._flushData(telemetryUrl + '/v1/metrics/usage/beacon', telemetryCacheAdapter, this.serviceApi.postMetricsUsage);
+      }
     }
 
     // Close streaming connection

package/src/readiness/sdkReadinessManager.ts

@@ -15,18 +15,16 @@ const REMOVE_LISTENER_EVENT = 'removeListener';
  * It also updates logs related warnings and errors.
  *
  * @param readyTimeout time in millis to emit SDK_READY_TIME_OUT event
- * @param internalReadyCbCount offset value of SDK_READY listeners that are added/removed internally
- * by the SDK. It is required to properly log the warning 'No listeners for SDK Readiness detected'
  * @param readinessManager optional readinessManager to use. only used internally for `shared` method
  */
 export function sdkReadinessManagerFactory(
   log: ILogger,
   EventEmitter: new () => IEventEmitter,
   readyTimeout = 0,
-  internalReadyCbCount = 0,
   readinessManager = readinessManagerFactory(EventEmitter, readyTimeout)): ISdkReadinessManager {
 
   /** Ready callback warning */
+  let internalReadyCbCount = 0;
   let readyCbCount = 0;
   readinessManager.gate.on(REMOVE_LISTENER_EVENT, (event: any) => {
     if (event === SDK_READY) readyCbCount--;
@@ -74,8 +72,12 @@ export function sdkReadinessManagerFactory(
   return {
     readinessManager,
 
-    shared(readyTimeout = 0, internalReadyCbCount = 0) {
-      return sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, internalReadyCbCount, readinessManager.shared(readyTimeout));
+    shared(readyTimeout = 0) {
+      return sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, readinessManager.shared(readyTimeout));
+    },
+
+    incInternalReadyCbCount() {
+      internalReadyCbCount++;
     },
 
     sdkStatus: objectAssign(

package/src/readiness/types.ts

@@ -66,6 +66,12 @@ export interface ISdkReadinessManager {
   readinessManager: IReadinessManager
   sdkStatus: IStatusInterface
 
+  /**
+   * Increment internalReadyCbCount, an offset value of SDK_READY listeners that are added/removed internally
+   * by the SDK. It is required to properly log the warning 'No listeners for SDK Readiness detected'
+   */
+  incInternalReadyCbCount(): void
+
   /** for client-side */
-  shared(readyTimeout?: number, internalReadyCbCount?: number): ISdkReadinessManager
+  shared(readyTimeout?: number): ISdkReadinessManager
 }

package/src/services/splitApi.ts

@@ -108,12 +108,12 @@ export function splitApiFactory(
     },
 
     postMetricsConfig(body: string) {
-      const url = `${urls.telemetry}/metrics/config`;
+      const url = `${urls.telemetry}/v1/metrics/config`;
       return splitHttpClient(url, { method: 'POST', body }, telemetryTracker.trackHttp(TELEMETRY), true);
     },
 
     postMetricsUsage(body: string) {
-      const url = `${urls.telemetry}/metrics/usage`;
+      const url = `${urls.telemetry}/v1/metrics/usage`;
       return splitHttpClient(url, { method: 'POST', body }, telemetryTracker.trackHttp(TELEMETRY), true);
     }
   };

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/submitter.ts

@@ -16,7 +16,7 @@ export function submitterFactory<TState>(
   dataName: string,
   fromCacheToPayload?: (cacheData: TState) => any,
   maxRetries: number = 0,
-  debugLogs?: boolean
+  debugLogs?: boolean // true for telemetry submitters
 ): ISyncTask<[], void> {
 
   let retries = 0;
@@ -37,14 +37,14 @@ export function submitterFactory<TState>(
       sourceCache.clear(); // we clear the queue if request successes.
     }).catch(err => {
       if (!maxRetries) {
-        log.warn(SUBMITTERS_PUSH_FAILS, [dataCountMessage, err]);
+        log[debugLogs ? 'debug' : 'warn'](SUBMITTERS_PUSH_FAILS, [dataCountMessage, err]);
       } else if (retries === maxRetries) {
         retries = 0;
         sourceCache.clear(); // we clear the queue if request fails after retries.
-        log.warn(SUBMITTERS_PUSH_FAILS, [dataCountMessage, err]);
+        log[debugLogs ? 'debug' : 'warn'](SUBMITTERS_PUSH_FAILS, [dataCountMessage, err]);
       } else {
         retries++;
-        log.warn(SUBMITTERS_PUSH_RETRY, [dataCountMessage, err]);
+        log[debugLogs ? 'debug' : 'warn'](SUBMITTERS_PUSH_RETRY, [dataCountMessage, err]);
       }
     });
   }

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, (0 | 1 | 2 | 3)>;
+
 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.
  */
@@ -75,9 +91,7 @@ export function telemetryCacheConfigAdapter(telemetry: ITelemetryCacheSync, sett
     state(): TelemetryConfigStatsPayload {
       const { urls, scheduler } = settings;
 
-      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,
@@ -98,14 +112,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
+      });
     }
   };
 }
@@ -117,7 +130,7 @@ export function telemetrySubmitterFactory(params: ISdkFactoryContextSync) {
   const { storage: { splits, segments, telemetry } } = params;
   if (!telemetry) return; // No submitter created if telemetry cache is not defined
 
-  const { settings, settings: { log, scheduler: { telemetryRefreshRate } }, splitApi, platform: { now }, readiness } = params;
+  const { settings, settings: { log, scheduler: { telemetryRefreshRate } }, splitApi, platform: { now }, readiness, sdkReadinessManager } = params;
   const startTime = timer(now || Date.now);
 
   const submitter = firstPushWindowDecorator(
@@ -129,6 +142,7 @@ export function telemetrySubmitterFactory(params: ISdkFactoryContextSync) {
     telemetry.recordTimeUntilReadyFromCache(startTime());
   });
 
+  sdkReadinessManager.incInternalReadyCbCount();
   readiness.gate.once(SDK_READY, () => {
     telemetry.recordTimeUntilReady(startTime());
 

package/src/sync/submitters/types.ts

@@ -165,10 +165,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 +184,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/types.ts

@@ -684,7 +684,7 @@ export namespace SplitIO {
     /**
      * String property to override the base URL where the SDK will post telemetry data.
      * @property {string} telemetry
-     * @default 'https://telemetry.split.io'
+     * @default 'https://telemetry.split.io/api'
      */
     telemetry?: string
   };

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/settingsValidation/index.ts

@@ -1,7 +1,7 @@
 import { merge } from '../lang';
 import { mode } from './mode';
 import { validateSplitFilters } from './splitFilters';
-import { STANDALONE_MODE, OPTIMIZED, LOCALHOST_MODE } from '../constants';
+import { STANDALONE_MODE, OPTIMIZED, LOCALHOST_MODE, DEBUG } from '../constants';
 import { validImpressionsMode } from './impressionsMode';
 import { ISettingsValidationParams } from './types';
 import { ISettings } from '../../types';
@@ -34,8 +34,8 @@ export const base = {
     segmentsRefreshRate: 60,
     // publish telemetry stats each 3600 secs (1 hour)
     telemetryRefreshRate: 3600,
-    // publish evaluations each 60 sec
-    impressionsRefreshRate: 60,
+    // publish evaluations each 300 sec (default value for OPTIMIZED impressions mode)
+    impressionsRefreshRate: 300,
     // fetch offline changes each 15 sec
     offlineRefreshRate: 15,
     // publish events every 60 seconds after the first flush
@@ -58,7 +58,7 @@ export const base = {
     // Streaming Server
     streaming: 'https://streaming.split.io',
     // Telemetry Server
-    telemetry: 'https://telemetry.split.io',
+    telemetry: 'https://telemetry.split.io/api',
   },
 
   // Defines which kind of storage we should instanciate.
@@ -113,6 +113,9 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   const log = logger(withDefaults); // @ts-ignore, modify readonly prop
   withDefaults.log = log;
 
+  // ensure a valid impressionsMode
+  withDefaults.sync.impressionsMode = validImpressionsMode(log, withDefaults.sync.impressionsMode);
+
   function validateMinValue(paramName: string, actualValue: number, minValue: number) {
     if (actualValue >= minValue) return actualValue;
     // actualValue is not a number or is lower than minValue
@@ -124,11 +127,21 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   const { scheduler, startup } = withDefaults;
   scheduler.featuresRefreshRate = fromSecondsToMillis(scheduler.featuresRefreshRate);
   scheduler.segmentsRefreshRate = fromSecondsToMillis(scheduler.segmentsRefreshRate);
-  scheduler.impressionsRefreshRate = fromSecondsToMillis(scheduler.impressionsRefreshRate);
   scheduler.offlineRefreshRate = fromSecondsToMillis(scheduler.offlineRefreshRate);
   scheduler.eventsPushRate = fromSecondsToMillis(scheduler.eventsPushRate);
   scheduler.telemetryRefreshRate = fromSecondsToMillis(validateMinValue('telemetryRefreshRate', scheduler.telemetryRefreshRate, 60));
 
+  if (scheduler.impressionsRefreshRate !== base.scheduler.impressionsRefreshRate) {
+    // Validate impressionsRefreshRate defined by user
+    scheduler.impressionsRefreshRate = validateMinValue('impressionsRefreshRate', scheduler.impressionsRefreshRate,
+      withDefaults.sync.impressionsMode === DEBUG ? 1 : 60 // Min is 1 sec for DEBUG and 60 secs for OPTIMIZED
+    );
+  } else {
+    // Default impressionsRefreshRate for DEBUG mode is 60 secs
+    if (withDefaults.sync.impressionsMode === DEBUG) scheduler.impressionsRefreshRate = 60;
+  }
+  scheduler.impressionsRefreshRate = fromSecondsToMillis(scheduler.impressionsRefreshRate);
+
   // Log deprecation for old telemetry param
   if (scheduler.metricsRefreshRate) log.warn('`metricsRefreshRate` will be deprecated soon. For configuring telemetry rates, update `telemetryRefreshRate` value in configs');
 
@@ -190,9 +203,6 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   withDefaults.sync.splitFilters = splitFiltersValidation.validFilters;
   withDefaults.sync.__splitFiltersValidation = splitFiltersValidation;
 
-  // ensure a valid impressionsMode
-  withDefaults.sync.impressionsMode = validImpressionsMode(log, withDefaults.sync.impressionsMode);
-
   // ensure a valid user consent value
   // @ts-ignore, modify readonly prop
   withDefaults.userConsent = consent(withDefaults);

package/src/utils/settingsValidation/url.ts

@@ -1,6 +1,6 @@
 import { ISettings } from '../../types';
 
-const telemetryEndpointMatcher = /^\/metrics\/(config|usage)/;
+const telemetryEndpointMatcher = /^\/v1\/metrics\/(config|usage)/;
 const eventsEndpointMatcher = /^\/(testImpressions|metrics|events)/;
 const authEndpointMatcher = /^\/v2\/auth/;
 const streamingEndpointMatcher = /^\/(sse|event-stream)/;

package/types/readiness/sdkReadinessManager.d.ts

@@ -6,8 +6,6 @@ import { ILogger } from '../logger/types';
  * It also updates logs related warnings and errors.
  *
  * @param readyTimeout time in millis to emit SDK_READY_TIME_OUT event
- * @param internalReadyCbCount offset value of SDK_READY listeners that are added/removed internally
- * by the SDK. It is required to properly log the warning 'No listeners for SDK Readiness detected'
  * @param readinessManager optional readinessManager to use. only used internally for `shared` method
  */
-export declare function sdkReadinessManagerFactory(log: ILogger, EventEmitter: new () => IEventEmitter, readyTimeout?: number, internalReadyCbCount?: number, readinessManager?: import("./types").IReadinessManager): ISdkReadinessManager;
+export declare function sdkReadinessManagerFactory(log: ILogger, EventEmitter: new () => IEventEmitter, readyTimeout?: number, readinessManager?: import("./types").IReadinessManager): ISdkReadinessManager;

package/types/readiness/types.d.ts

@@ -49,7 +49,12 @@ export interface IReadinessManager {
 export interface ISdkReadinessManager {
     readinessManager: IReadinessManager;
     sdkStatus: IStatusInterface;
+    /**
+     * Increment internalReadyCbCount, an offset value of SDK_READY listeners that are added/removed internally
+     * by the SDK. It is required to properly log the warning 'No listeners for SDK Readiness detected'
+     */
+    incInternalReadyCbCount(): void;
     /** for client-side */
-    shared(readyTimeout?: number, internalReadyCbCount?: number): ISdkReadinessManager;
+    shared(readyTimeout?: number): ISdkReadinessManager;
 }
 export {};