@splitsoftware/splitio-commons 1.6.2-rc.1 → 1.6.2-rc.10

package/src/sync/offline/syncTasks/fromObjectSyncTask.ts

@@ -2,7 +2,7 @@ import { forOwn } from '../../../utils/lang';
 import { IReadinessManager } from '../../../readiness/types';
 import { ISplitsCacheSync } from '../../../storages/types';
 import { ISplitsParser } from '../splitsParser/types';
-import { ISplitPartial } from '../../../dtos/types';
+import { ISplit, ISplitPartial } from '../../../dtos/types';
 import { syncTaskFactory } from '../../syncTask';
 import { ISyncTask } from '../../types';
 import { ISettings } from '../../../types';
@@ -24,7 +24,7 @@ export function fromObjectUpdaterFactory(
   let startingUp = true;
 
   return function objectUpdater() {
-    const splits: [string, string][] = [];
+    const splits: [string, ISplit][] = [];
     let loadError = null;
     let splitsMock: false | Record<string, ISplitPartial> = {};
     try {
@@ -38,9 +38,8 @@ export function fromObjectUpdaterFactory(
       log.debug(SYNC_OFFLINE_DATA, [JSON.stringify(splitsMock)]);
 
       forOwn(splitsMock, function (val, name) {
-        splits.push([
-          name,
-          JSON.stringify({
+        splits.push([ // @ts-ignore Split changeNumber and seed is undefined in localhost mode
+          name, {
             name,
             status: 'ACTIVE',
             killed: false,
@@ -49,7 +48,7 @@ export function fromObjectUpdaterFactory(
             conditions: val.conditions || [],
             configurations: val.configurations,
             trafficTypeName: val.trafficTypeName
-          })
+          }
         ]);
       });
 

package/src/sync/polling/updaters/splitChangesUpdater.ts

@@ -40,7 +40,7 @@ export function parseSegments({ conditions }: ISplit): ISet<string> {
 }
 
 interface ISplitMutations {
-  added: [string, string][],
+  added: [string, ISplit][],
   removed: string[],
   segments: string[]
 }
@@ -54,7 +54,7 @@ export function computeSplitsMutation(entries: ISplit[]): ISplitMutations {
   const segments = new _Set<string>();
   const computed = entries.reduce((accum, split) => {
     if (split.status === 'ACTIVE') {
-      accum.added.push([split.name, JSON.stringify(split)]);
+      accum.added.push([split.name, split]);
 
       parseSegments(split).forEach((segmentName: string) => {
         segments.add(segmentName);

package/src/sync/submitters/telemetrySubmitter.ts

@@ -1,7 +1,7 @@
 import { ISegmentsCacheSync, ISplitsCacheSync, ITelemetryCacheSync } from '../../storages/types';
 import { submitterFactory, firstPushWindowDecorator } from './submitter';
 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 { QUEUED, DEDUPED, DROPPED, CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, NONE, DEBUG_ENUM, OPTIMIZED_ENUM, NONE_ENUM, CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../../utils/constants';
 import { SDK_READY, SDK_READY_FROM_CACHE } from '../../readiness/constants';
 import { ConsentStatus, ISettings, SDKMode } from '../../types';
 import { base } from '../../utils/settingsValidation';
@@ -9,11 +9,12 @@ import { usedKeysMap } from '../../utils/inputValidation/apiKey';
 import { timer } from '../../utils/timeTracker/timer';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 import { objectAssign } from '../../utils/lang/objectAssign';
+import { isStorageSync } from '../../trackers/impressionObserver/utils';
 
 /**
  * Converts data from telemetry cache into /metrics/usage request payload.
  */
-export function telemetryCacheStatsAdapter(telemetry: ITelemetryCacheSync, splits: ISplitsCacheSync, segments: ISegmentsCacheSync) {
+export function telemetryCacheStatsAdapter(telemetry: ITelemetryCacheSync, splits?: ISplitsCacheSync, segments?: ISegmentsCacheSync) {
   return {
     isEmpty() { return false; }, // There is always data in telemetry cache
     clear() { }, //  No-op
@@ -31,9 +32,9 @@ export function telemetryCacheStatsAdapter(telemetry: ITelemetryCacheSync, split
         iQ: telemetry.getImpressionStats(QUEUED),
         iDe: telemetry.getImpressionStats(DEDUPED),
         iDr: telemetry.getImpressionStats(DROPPED),
-        spC: splits.getSplitNames().length,
-        seC: segments.getRegisteredSegments().length,
-        skC: segments.getKeysCount(),
+        spC: splits && splits.getSplitNames().length,
+        seC: segments && segments.getRegisteredSegments().length,
+        skC: segments && segments.getKeysCount(),
         sL: telemetry.getSessionLength(),
         eQ: telemetry.getEventStats(QUEUED),
         eD: telemetry.getEventStats(DROPPED),
@@ -52,8 +53,9 @@ const OPERATION_MODE_MAP = {
 
 const IMPRESSIONS_MODE_MAP = {
   [OPTIMIZED]: OPTIMIZED_ENUM,
-  [DEBUG]: DEBUG_ENUM
-} as Record<ISettings['sync']['impressionsMode'], (0 | 1)>;
+  [DEBUG]: DEBUG_ENUM,
+  [NONE]: NONE_ENUM
+} as Record<ISettings['sync']['impressionsMode'], (0 | 1 | 2)>;
 
 const USER_CONSENT_MAP = {
   [CONSENT_UNKNOWN]: 1,
@@ -136,7 +138,12 @@ export function telemetrySubmitterFactory(params: ISdkFactoryContextSync) {
   const startTime = timer(now);
 
   const submitter = firstPushWindowDecorator(
-    submitterFactory(log, splitApi.postMetricsUsage, telemetryCacheStatsAdapter(telemetry, splits, segments), telemetryRefreshRate, 'telemetry stats', undefined, 0, true),
+    submitterFactory(
+      log, splitApi.postMetricsUsage,
+      // @TODO cannot provide splits and segments cache if they are async, because `submitterFactory` expects a sync storage source
+      isStorageSync(params.settings) ? telemetryCacheStatsAdapter(telemetry, splits, segments) : telemetryCacheStatsAdapter(telemetry),
+      telemetryRefreshRate, 'telemetry stats', undefined, 0, true
+    ),
     telemetryRefreshRate
   );
 

package/src/sync/submitters/types.ts

@@ -1,5 +1,7 @@
+/* eslint-disable no-use-before-define */
 import { IMetadata } from '../../dtos/types';
 import { SplitIO } from '../../types';
+import { IMap } from '../../utils/lang/maps';
 import { ISyncTask } from '../types';
 
 export type ImpressionsPayload = {
@@ -82,6 +84,12 @@ export type StoredEventWithMetadata = {
   e: SplitIO.EventData
 }
 
+export type MultiMethodLatencies = IMap<string, MethodLatencies>
+
+export type MultiMethodExceptions = IMap<string, MethodExceptions>
+
+export type MultiConfigs = IMap<string, TelemetryConfigStats>
+
 /**
  * Telemetry usage stats
  */
@@ -133,11 +141,15 @@ export type StreamingEvent = {
   t: number, // timestamp
 }
 
+// 'telemetry.latencias' and 'telemetry.exceptions' Redis/Pluggable keys
+export type TelemetryUsageStats = {
+  mL?: MethodLatencies, // clientMethodLatencies
+  mE?: MethodExceptions, // methodExceptions
+}
+
 // 'metrics/usage' JSON request body
-export type TelemetryUsageStatsPayload = {
+export type TelemetryUsageStatsPayload = TelemetryUsageStats & {
   lS: LastSync, // lastSynchronization
-  mL: MethodLatencies, // clientMethodLatencies
-  mE: MethodExceptions, // methodExceptions
   hE: HttpErrors, // httpErrors
   hL: HttpLatencies, // httpLatencies
   tR: number, // tokenRefreshes
@@ -145,9 +157,9 @@ export type TelemetryUsageStatsPayload = {
   iQ: number, // impressionsQueued
   iDe: number, // impressionsDeduped
   iDr: number, // impressionsDropped
-  spC: number, // splitCount
-  seC: number, // segmentCount
-  skC: number, // segmentKeyCount
+  spC?: number, // splitCount
+  seC?: number, // segmentCount
+  skC?: number, // segmentKeyCount
   sL?: number, // sessionLengthMs
   eQ: number, // eventsQueued
   eD: number, // eventsDropped

package/src/sync/submitters/uniqueKeysSubmitter.ts

@@ -1,63 +1,9 @@
+import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
-import { ISet, setToArray } from '../../utils/lang/sets';
 import { submitterFactory } from './submitter';
-import { UniqueKeysPayloadCs, UniqueKeysPayloadSs } from './types';
 
-/** 
- * Invert keys for feature to features for key
- */
-function invertUniqueKeys(uniqueKeys: { [featureName: string]: ISet<string> }): { [key: string]: string[] } {
-  const featureNames = Object.keys(uniqueKeys);
-  const inverted: { [key: string]: string[] } = {};
-  for (let i = 0; i < featureNames.length; i++) {
-    const featureName = featureNames[i];
-    const featureKeys = setToArray(uniqueKeys[featureName]);
-    for (let j = 0; j< featureKeys.length; j++) {
-      const featureKey = featureKeys[j];
-      if (!inverted[featureKey]) inverted[featureKey] = []; 
-      inverted[featureKey].push(featureName);
-    }
-  }
-  return inverted;
-}
-
-/**
- * Converts `uniqueKeys` data from cache into request payload for CS.
- */
-export function fromUniqueKeysCollectorCs(uniqueKeys: { [featureName: string]: ISet<string> }): UniqueKeysPayloadCs {
-  const payload = [];
-  const featuresPerKey = invertUniqueKeys(uniqueKeys);
-  const keys = Object.keys(featuresPerKey);
-  for (let k = 0; k < keys.length; k++) {
-    const key = keys[k];
-    const uniqueKeysPayload = {
-      k: key,
-      fs: featuresPerKey[key]
-    };
-
-    payload.push(uniqueKeysPayload);
-  }
-  return { keys: payload };
-}
-
-/**
- * Converts `uniqueKeys` data from cache into request payload for SS.
- */
-export function fromUniqueKeysCollectorSs(uniqueKeys: { [featureName: string]: ISet<string> }): UniqueKeysPayloadSs {
-  const payload = [];
-  const featureNames = Object.keys(uniqueKeys);
-  for (let i = 0; i < featureNames.length; i++) {
-    const featureName = featureNames[i];
-    const featureKeys = setToArray(uniqueKeys[featureName]);
-    const uniqueKeysPayload = {
-      f: featureName,
-      ks: featureKeys
-    };
-
-    payload.push(uniqueKeysPayload);
-  }
-  return { keys: payload };
-}
+const DATA_NAME = 'unique keys';
+const UNIQUE_KEYS_RATE = 900000; // 15 minutes
 
 /**
  * Submitter that periodically posts impression counts
@@ -65,15 +11,26 @@ export function fromUniqueKeysCollectorSs(uniqueKeys: { [featureName: string]: I
 export function uniqueKeysSubmitterFactory(params: ISdkFactoryContextSync) {
 
   const {
-    settings: { log, scheduler: { uniqueKeysRefreshRate }, core: {key}},
+    settings: { log, core: { key } },
     splitApi: { postUniqueKeysBulkCs, postUniqueKeysBulkSs },
     storage: { uniqueKeys }
   } = params;
-  
+
   const isClientSide = key !== undefined;
   const postUniqueKeysBulk = isClientSide ? postUniqueKeysBulkCs : postUniqueKeysBulkSs;
-  const fromUniqueKeysCollector = isClientSide ? fromUniqueKeysCollectorCs : fromUniqueKeysCollectorSs;
 
-  return submitterFactory(log, postUniqueKeysBulk, uniqueKeys!, uniqueKeysRefreshRate, 'unique keys', fromUniqueKeysCollector);
+  const syncTask = submitterFactory(log, postUniqueKeysBulk, uniqueKeys!, UNIQUE_KEYS_RATE, DATA_NAME);
+
+  // register unique keys submitter to be executed when uniqueKeys cache is full
+  uniqueKeys!.setOnFullQueueCb(() => {
+    if (syncTask.isRunning()) {
+      log.info(SUBMITTERS_PUSH_FULL_QUEUE, [DATA_NAME]);
+      syncTask.execute();
+    }
+    // If submitter is stopped (e.g., user consent declined or unknown, or app state offline), we don't send the data.
+    // Data will be sent when submitter is resumed.
+  });
+
+  return syncTask;
 }
 

package/src/trackers/impressionsTracker.ts

@@ -30,26 +30,27 @@ export function impressionsTrackerFactory(
       if (settings.userConsent === CONSENT_DECLINED) return;
 
       const impressionsCount = impressions.length;
-
       const { impressionsToStore, impressionsToListener, deduped } = strategy.process(impressions);
       
       const impressionsToListenerCount = impressionsToListener.length;
       
-      const res = impressionsCache.track(impressionsToStore);
+      if ( impressionsToStore.length>0 ){
+        const res = impressionsCache.track(impressionsToStore);
 
-      // If we're on an async storage, handle error and log it.
-      if (thenable(res)) {
-        res.then(() => {
-          log.info(IMPRESSIONS_TRACKER_SUCCESS, [impressionsCount]);
-        }).catch(err => {
-          log.error(ERROR_IMPRESSIONS_TRACKER, [impressionsCount, err]);
-        });
-      } else {
-        // Record when impressionsCache is sync only (standalone mode)
-        // @TODO we are not dropping impressions on full queue yet, so DROPPED stats are not recorded
-        if (telemetryCache) {
-          (telemetryCache as ITelemetryCacheSync).recordImpressionStats(QUEUED, impressionsToStore.length);
-          (telemetryCache as ITelemetryCacheSync).recordImpressionStats(DEDUPED, deduped);
+        // If we're on an async storage, handle error and log it.
+        if (thenable(res)) {
+          res.then(() => {
+            log.info(IMPRESSIONS_TRACKER_SUCCESS, [impressionsCount]);
+          }).catch(err => {
+            log.error(ERROR_IMPRESSIONS_TRACKER, [impressionsCount, err]);
+          });
+        } else {
+          // Record when impressionsCache is sync only (standalone mode)
+          // @TODO we are not dropping impressions on full queue yet, so DROPPED stats are not recorded
+          if (telemetryCache) {
+            (telemetryCache as ITelemetryCacheSync).recordImpressionStats(QUEUED, impressionsToStore.length);
+            (telemetryCache as ITelemetryCacheSync).recordImpressionStats(DEDUPED, deduped);
+          }
         }
       }
 

package/src/trackers/strategy/strategyNone.ts

@@ -21,7 +21,7 @@ export function strategyNoneFactory(
         // Increments impression counter per featureName
         impressionsCounter.track(impression.feature, now, 1);
         // Keep track by unique key
-        uniqueKeysTracker.track(impression.feature, impression.keyName);
+        uniqueKeysTracker.track(impression.keyName, impression.feature);
       });
       
       return {

package/src/trackers/strategy/strategyOptimized.ts

@@ -25,7 +25,7 @@ export function strategyOptimizedFactory(
         const now = Date.now();
         
         // Increments impression counter per featureName
-        impressionsCounter.track(impression.feature, now, 1);
+        if (impression.pt) impressionsCounter.track(impression.feature, now, 1);
   
         // Checks if the impression should be added in queue to be sent
         if (!impression.pt || impression.pt < truncateTimeFrame(now)) {

package/src/trackers/telemetryTracker.ts

@@ -48,6 +48,10 @@ export function telemetryTrackerFactory(
           });
           if (e === TOKEN_REFRESH) (telemetryCache as ITelemetryCacheSync).recordTokenRefreshes();
         }
+      },
+      addTag(tag: string) {
+        // @ts-ignore
+        if (telemetryCache.addTag) telemetryCache.addTag(tag);
       }
     };
 
@@ -56,8 +60,9 @@ export function telemetryTrackerFactory(
     return {
       trackEval: noopTrack,
       trackHttp: noopTrack,
-      sessionLength: () => { },
-      streamingEvent: () => { },
+      sessionLength() { },
+      streamingEvent() { },
+      addTag() { }
     };
   }
 }

package/src/trackers/types.ts

@@ -2,7 +2,6 @@ import { SplitIO, ImpressionDTO } from '../types';
 import { StreamingEventType, Method, OperationType } from '../sync/submitters/types';
 import { IEventsCacheBase } from '../storages/types';
 import { NetworkError } from '../services/types';
-import { ISet } from '../utils/lang/sets';
 
 /** Events tracker */
 
@@ -42,12 +41,17 @@ export interface ITelemetryTracker {
    * Records streaming event
    */
   streamingEvent(e: StreamingEventType | AUTH_REJECTION, d?: number): void
+  /**
+   * Records tag
+   */
+  addTag(tag: string): void
 }
 
 export interface IFilterAdapter {
-  add(featureName: string, key: string): boolean;
-  contains(featureName: string, key: string): boolean;
+  add(key: string, featureName: string): boolean;
+  contains(key: string, featureName: string): boolean;
   clear(): void;
+  refreshRate?: number;
 }
 
 export interface IImpressionSenderAdapter {
@@ -57,10 +61,8 @@ export interface IImpressionSenderAdapter {
 
 /** Unique keys tracker */
 export interface IUniqueKeysTracker {
-  track(featureName: string, key: string): void;
-  pop(toMerge?: { [featureName: string]: ISet<string> }): { [featureName: string]: ISet<string>; };
-  clear(): void;
-  isEmpty(): boolean;
+  stop(): void;
+  track(key: string, featureName: string): void;
 }
 
 export interface IStrategyResult {

package/src/trackers/uniqueKeysTracker.ts

@@ -1,6 +1,6 @@
 import { LOG_PREFIX_UNIQUE_KEYS_TRACKER } from '../logger/constants';
 import { ILogger } from '../logger/types';
-import { ISet, _Set } from '../utils/lang/sets';
+import { IUniqueKeysCacheBase } from '../storages/types';
 import { IFilterAdapter, IUniqueKeysTracker } from './types';
 
 const noopFilterAdapter = {
@@ -9,70 +9,38 @@ const noopFilterAdapter = {
   clear() {}
 };
 
-const DEFAULT_CACHE_SIZE = 30000;
 /**
  * Trackes uniques keys
  * Unique Keys Tracker will be in charge of checking if the MTK was already sent to the BE in the last period
  *  or schedule to be sent; if not it will be added in an internal cache and sent in the next post. 
  * 
  * @param log Logger instance
+ * @param uniqueKeysCache cache to save unique keys
  * @param filterAdapter filter adapter
- * @param cacheSize optional internal cache size
- * @param maxBulkSize optional max MTKs bulk size
  */
 export function uniqueKeysTrackerFactory(
   log: ILogger,
+  uniqueKeysCache: IUniqueKeysCacheBase,
   filterAdapter: IFilterAdapter = noopFilterAdapter,
-  cacheSize = DEFAULT_CACHE_SIZE,
-  // @TODO
-  // maxBulkSize: number = 5000,
 ): IUniqueKeysTracker {
-  
-  let uniqueKeysTracker: { [featureName: string]: ISet<string> } = {};
-  let uniqueTrackerSize = 0;
-  
+  let intervalId: any;
+
+  if (filterAdapter.refreshRate) {
+    intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
+  }
+
   return {
-    track(featureName: string, key: string): void {
-      if (!filterAdapter.add(featureName, key)) {
+
+    track(key: string, featureName: string): void {
+      if (!filterAdapter.add(key, featureName)) {
         log.debug(`${LOG_PREFIX_UNIQUE_KEYS_TRACKER}The feature ${featureName} and key ${key} exist in the filter`);
         return;
       }
-      if (!uniqueKeysTracker[featureName]) uniqueKeysTracker[featureName] = new _Set();
-      const tracker = uniqueKeysTracker[featureName];
-      if (!tracker.has(key)) {
-        tracker.add(key);
-        log.debug(`${LOG_PREFIX_UNIQUE_KEYS_TRACKER}Key ${key} added to feature ${featureName}`);
-        uniqueTrackerSize++;
-      }
-      
-      if (uniqueTrackerSize >= cacheSize) {
-        log.warn(`${LOG_PREFIX_UNIQUE_KEYS_TRACKER}The UniqueKeysTracker size reached the maximum limit`);
-        // @TODO trigger event to submitter to send mtk
-        uniqueTrackerSize = 0;
-      }
-    },
-    
-    /**
-     * Pop the collected data, used as payload for posting.
-     */
-    pop() {
-      const data = uniqueKeysTracker;
-      uniqueKeysTracker = {};
-      return data;
-    },
-
-    /**
-     * Clear the data stored on the cache.
-     */
-    clear() {
-      uniqueKeysTracker = {};
+      uniqueKeysCache.track(key, featureName);
     },
 
-    /**
-     * Check if the cache is empty.
-     */
-    isEmpty() {
-      return Object.keys(uniqueKeysTracker).length === 0;
+    stop(): void {
+      clearInterval(intervalId);
     }
     
   };

package/src/types.ts

@@ -80,7 +80,6 @@ export interface ISettings {
     featuresRefreshRate: number,
     impressionsRefreshRate: number,
     impressionsQueueSize: number,
-    uniqueKeysRefreshRate: number,
     /**
      * @deprecated
      */

package/src/utils/constants/index.ts

@@ -50,6 +50,7 @@ export const CONSUMER_PARTIAL_ENUM = 2;
 
 export const OPTIMIZED_ENUM = 0;
 export const DEBUG_ENUM = 1;
+export const NONE_ENUM = 2;
 
 export const SPLITS = 'sp';
 export const IMPRESSIONS = 'im';

package/src/utils/lang/maps.ts

@@ -24,10 +24,12 @@ THE SOFTWARE.
 **/
 
 export interface IMap<K, V> {
-  set(key: K, value: V): this;
   clear(): void;
   delete(key: K): boolean;
+  forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
   get(key: K): V | undefined;
+  has(key: K): boolean;
+  set(key: K, value: V): this;
   readonly size: number;
 }
 
@@ -46,13 +48,6 @@ export class MapPoly<K, V> implements IMap<K, V>{
     this.__mapValuesData__.length = 0;
   }
 
-  set(key: K, value: V) {
-    let index = this.__mapKeysData__.indexOf(key);
-    if (index === -1) index = this.__mapKeysData__.push(key) - 1;
-    this.__mapValuesData__[index] = value;
-    return this;
-  }
-
   delete(key: K) {
     const index = this.__mapKeysData__.indexOf(key);
     if (index === -1) return false;
@@ -61,12 +56,29 @@ export class MapPoly<K, V> implements IMap<K, V>{
     return true;
   }
 
+  forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any) {
+    for (let i = 0; i < this.__mapKeysData__.length; i++) {
+      callbackfn.call(thisArg, this.__mapValuesData__[i], this.__mapKeysData__[i], this as any);
+    }
+  }
+
   get(key: K) {
     const index = this.__mapKeysData__.indexOf(key);
     if (index === -1) return;
     return this.__mapValuesData__[index];
   }
 
+  has(key: K): boolean {
+    return this.__mapKeysData__.indexOf(key) !== -1;
+  }
+
+  set(key: K, value: V) {
+    let index = this.__mapKeysData__.indexOf(key);
+    if (index === -1) index = this.__mapKeysData__.push(key) - 1;
+    this.__mapValuesData__[index] = value;
+    return this;
+  }
+
   get size() {
     return this.__mapKeysData__.length;
   }

package/src/utils/redis/RedisMock.ts

@@ -0,0 +1,33 @@
+//@ts-nocheck
+function identityFunction(data: any): any {
+  return data;
+}
+
+function asyncFunction(data: any): Promise<any> {
+  return Promise.resolve(data);
+}
+
+const IDENTITY_METHODS: string[] = [];
+const ASYNC_METHODS = ['rpush', 'hincrby'];
+const PIPELINE_METHODS = ['rpush', 'hincrby'];
+
+export class RedisMock {
+  
+  private pipelineMethods: any = { exec: jest.fn(asyncFunction) }
+  
+  constructor() {
+    IDENTITY_METHODS.forEach(method => {
+      this[method] = jest.fn(identityFunction);
+    });
+    ASYNC_METHODS.forEach(method => {
+      this[method] = jest.fn(asyncFunction);
+    });
+    PIPELINE_METHODS.forEach(method => {
+      this.pipelineMethods[method] = this[method];
+    });
+    
+    this.pipeline = jest.fn(() => {return this.pipelineMethods;});
+  }
+  
+  
+}

package/src/utils/settingsValidation/index.ts

@@ -36,8 +36,6 @@ export const base = {
     telemetryRefreshRate: 3600,
     // publish evaluations each 300 sec (default value for OPTIMIZED impressions mode)
     impressionsRefreshRate: 300,
-    // publish unique Keys each 900 sec (15 min) 
-    uniqueKeysRefreshRate: 900,
     // fetch offline changes each 15 sec
     offlineRefreshRate: 15,
     // publish events every 60 seconds after the first flush
@@ -132,13 +130,12 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   scheduler.segmentsRefreshRate = fromSecondsToMillis(scheduler.segmentsRefreshRate);
   scheduler.offlineRefreshRate = fromSecondsToMillis(scheduler.offlineRefreshRate);
   scheduler.eventsPushRate = fromSecondsToMillis(scheduler.eventsPushRate);
-  scheduler.uniqueKeysRefreshRate = fromSecondsToMillis(scheduler.uniqueKeysRefreshRate);
   scheduler.telemetryRefreshRate = fromSecondsToMillis(validateMinValue('telemetryRefreshRate', scheduler.telemetryRefreshRate, 60));
 
   // Default impressionsRefreshRate for DEBUG mode is 60 secs
   if (get(config, 'scheduler.impressionsRefreshRate') === undefined && 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');

package/types/integrations/types.d.ts

@@ -1,5 +1,5 @@
 import { IEventsCacheBase } from '../storages/types';
-import { IEventsHandler, IImpressionsHandler } from '../trackers/types';
+import { IEventsHandler, IImpressionsHandler, ITelemetryTracker } from '../trackers/types';
 import { ISettings, SplitIO } from '../types';
 export interface IIntegration {
     queue(data: SplitIO.IntegrationData): void;
@@ -10,6 +10,7 @@ export interface IIntegrationFactoryParams {
         events: IEventsCacheBase;
     };
     settings: ISettings;
+    telemetryTracker: ITelemetryTracker;
 }
 export declare type IntegrationFactory = {
     readonly type: string;

package/types/services/types.d.ts

@@ -24,8 +24,8 @@ export declare type IPostUniqueKeysBulkCs = (body: string, headers?: Record<stri
 export declare type IPostUniqueKeysBulkSs = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
 export declare type IPostTestImpressionsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
 export declare type IPostTestImpressionsCount = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
-export declare type IPostMetricsConfig = (body: string) => Promise<IResponse>;
-export declare type IPostMetricsUsage = (body: string) => Promise<IResponse>;
+export declare type IPostMetricsConfig = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
+export declare type IPostMetricsUsage = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
 export interface ISplitApi {
     getSdkAPIHealthCheck: IHealthCheckAPI;
     getEventsAPIHealthCheck: IHealthCheckAPI;