@splitsoftware/splitio-commons 2.12.0 → 3.0.0-rc.0

package/src/sdkFactory/index.ts

@@ -4,16 +4,10 @@ import { impressionsTrackerFactory } from '../trackers/impressionsTracker';
 import { eventTrackerFactory } from '../trackers/eventTracker';
 import { telemetryTrackerFactory } from '../trackers/telemetryTracker';
 import SplitIO from '../../types/splitio';
-import { validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
 import { createLoggerAPI } from '../logger/sdkLogger';
 import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
 import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
-import { strategyDebugFactory } from '../trackers/strategy/strategyDebug';
-import { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized';
-import { strategyNoneFactory } from '../trackers/strategy/strategyNone';
-import { uniqueKeysTrackerFactory } from '../trackers/uniqueKeysTracker';
-import { DEBUG, OPTIMIZED } from '../utils/constants';
 import { setRolloutPlan } from '../storages/setRolloutPlan';
 import { IStorageSync } from '../storages/types';
 import { getMatching } from '../utils/key';
@@ -24,24 +18,13 @@ import { FallbackTreatmentsCalculator } from '../evaluator/fallbackTreatmentsCal
  */
 export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IAsyncSDK | SplitIO.IBrowserSDK | SplitIO.IBrowserAsyncSDK {
 
-  const { settings, platform, storageFactory, splitApiFactory, extraProps,
-    syncManagerFactory, SignalListener, impressionsObserverFactory,
-    integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory,
-    filterAdapterFactory, lazyInit } = params;
-  const { log, sync: { impressionsMode }, initialRolloutPlan, core: { key } } = settings;
+  const { settings, platform, storageFactory, splitApiFactory, extraProps, syncManagerFactory,
+    integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory, lazyInit } = params;
+  const { log, initialRolloutPlan, core: { key } } = settings;
 
   // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid SDK Key, etc.
   // On non-recoverable errors, we should mark the SDK as destroyed and not start synchronization.
 
-  // initialization
-  let hasInit = false;
-  const initCallbacks: (() => void)[] = [];
-
-  function whenInit(cb: () => void) {
-    if (hasInit) cb();
-    else initCallbacks.push(cb);
-  }
-
   const sdkReadinessManager = sdkReadinessManagerFactory(platform.EventEmitter, settings);
   const readiness = sdkReadinessManager.readinessManager;
 
@@ -61,40 +44,25 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
     }
   });
 
-  const fallbackTreatmentsCalculator = new FallbackTreatmentsCalculator(settings.fallbackTreatments);
+  const fallbackCalculator = FallbackTreatmentsCalculator(settings.fallbackTreatments);
 
   if (initialRolloutPlan) {
     setRolloutPlan(log, initialRolloutPlan, storage as IStorageSync, key && getMatching(key));
     if ((storage as IStorageSync).splits.getChangeNumber() > -1) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, { initialCacheLoad: false /* Not an initial load, cache exists */ });
   }
 
-  const clients: Record<string, SplitIO.IBasicClient> = {};
+  const clients: Record<string, SplitIO.IBasicClient & { init: () => void }> = {};
   const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
   const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage, telemetryTracker });
 
-  const observer = impressionsObserverFactory();
-  const uniqueKeysTracker = uniqueKeysTrackerFactory(log, storage.uniqueKeys, filterAdapterFactory && filterAdapterFactory());
-
-  const noneStrategy = strategyNoneFactory(storage.impressionCounts, uniqueKeysTracker);
-  const strategy = impressionsMode === OPTIMIZED ?
-    strategyOptimizedFactory(observer, storage.impressionCounts) :
-    impressionsMode === DEBUG ?
-      strategyDebugFactory(observer) :
-      noneStrategy;
-
-  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, noneStrategy, strategy, whenInit, integrationsManager, storage.telemetry);
-  const eventTracker = eventTrackerFactory(settings, storage.events, whenInit, integrationsManager, storage.telemetry);
+  const impressionsTracker = impressionsTrackerFactory(params, storage, integrationsManager);
+  const eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
 
   // splitApi is used by SyncManager and Browser signal listener
   const splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
 
-  const ctx: ISdkFactoryContext = { clients, splitApi, eventTracker, impressionsTracker, telemetryTracker, uniqueKeysTracker, sdkReadinessManager, readiness, settings, storage, platform, fallbackTreatmentsCalculator };
-
-  const syncManager = syncManagerFactory && syncManagerFactory(ctx as ISdkFactoryContextSync);
-  ctx.syncManager = syncManager;
-
-  const signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);
-  ctx.signalListener = signalListener;
+  const ctx: ISdkFactoryContext = { clients, splitApi, eventTracker, impressionsTracker, telemetryTracker, sdkReadinessManager, readiness, settings, storage, platform, fallbackCalculator };
+  ctx.syncManager = syncManagerFactory && syncManagerFactory(ctx as ISdkFactoryContextSync);
 
   // SDK client and manager
   const clientMethod = sdkClientMethodFactory(ctx);
@@ -102,18 +70,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
 
 
   function init() {
-    if (hasInit) return;
-    hasInit = true;
-
-    // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
-    validateAndTrackApiKey(log, settings.core.authorizationKey);
-    readiness.init();
-    uniqueKeysTracker.start();
-    syncManager && syncManager.start();
-    signalListener && signalListener.start();
-
-    initCallbacks.forEach((cb) => cb());
-    initCallbacks.length = 0;
+    Object.keys(clients).map(key => clients[key].init());
   }
 
   log.info(NEW_FACTORY, [settings.version]);
@@ -135,7 +92,6 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
     settings,
 
     destroy() {
-      hasInit = false;
       return Promise.all(Object.keys(clients).map(key => clients[key].destroy())).then(() => { });
     }
   }, extraProps && extraProps(ctx), lazyInit ? { init } : init());

package/src/sdkFactory/types.ts

@@ -3,12 +3,12 @@ import { ISignalListener } from '../listeners/types';
 import { IReadinessManager, ISdkReadinessManager } from '../readiness/types';
 import type { sdkManagerFactory } from '../sdkManager';
 import type { splitApiFactory } from '../services/splitApi';
-import type { IFallbackTreatmentsCalculator } from '../evaluator/fallbackTreatmentsCalculator';
+import type { IFallbackCalculator } from '../evaluator/fallbackTreatmentsCalculator';
 import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
 import { IStorageAsync, IStorageSync, IStorageFactoryParams } from '../storages/types';
 import { ISyncManager } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
-import { IImpressionsTracker, IEventTracker, ITelemetryTracker, IFilterAdapter, IUniqueKeysTracker } from '../trackers/types';
+import { IImpressionsTracker, IEventTracker, ITelemetryTracker, IFilterAdapter } from '../trackers/types';
 import { ISettings } from '../types';
 import SplitIO from '../../types/splitio';
 
@@ -35,9 +35,17 @@ export interface IPlatform {
   /**
    * Function used to track latencies for telemetry.
    */
-  now?: () => number
+  now?: () => number,
+  /**
+   * Optional signal listener constructor. Used to listen and handle runtime environment states, like server shutdown, app paused or resumed.
+   */
+  // eslint-disable-next-line no-use-before-define
+  SignalListener?: new (params: ISdkFactoryContext) => ISignalListener, // Used by BrowserSignalListener
 }
 
+// Definition type
+export type EntityType = 'config' | 'flag';
+
 export interface ISdkFactoryContext {
   platform: IPlatform,
   sdkReadinessManager: ISdkReadinessManager,
@@ -47,12 +55,11 @@ export interface ISdkFactoryContext {
   eventTracker: IEventTracker,
   telemetryTracker: ITelemetryTracker,
   storage: IStorageSync | IStorageAsync,
-  uniqueKeysTracker: IUniqueKeysTracker,
-  signalListener?: ISignalListener
-  splitApi?: ISplitApi
+  splitApi?: ISplitApi,
   syncManager?: ISyncManager,
   clients: Record<string, SplitIO.IBasicClient>,
-  fallbackTreatmentsCalculator: IFallbackTreatmentsCalculator
+  fallbackCalculator: IFallbackCalculator,
+  entityType?: EntityType
 }
 
 export interface ISdkFactoryContextSync extends ISdkFactoryContext {
@@ -98,21 +105,17 @@ export interface ISdkFactoryParams {
 
   // Sdk client method factory.
   // It Allows to distinguish SDK clients with the client-side API (`IBrowserSDK` and `IBrowserAsyncSDK`) or server-side API (`ISDK` and `IAsyncSDK`).
-  sdkClientMethodFactory: (params: ISdkFactoryContext) => ({ (): SplitIO.IBrowserClient; (key: SplitIO.SplitKey): SplitIO.IBrowserClient; } | (() => SplitIO.IClient) | (() => SplitIO.IAsyncClient))
+  sdkClientMethodFactory: (params: ISdkFactoryContext) => (
+    { (): SplitIO.IBrowserClient & { init(): void }; (key: SplitIO.SplitKey): SplitIO.IBrowserClient & { init(): void }; } |
+    (() => SplitIO.IClient & { init(): void }) |
+    (() => SplitIO.IAsyncClient & { init(): void })
+  )
 
   // Impression observer factory.
   impressionsObserverFactory: () => IImpressionObserver
 
   filterAdapterFactory?: () => IFilterAdapter
 
-  // Optional signal listener constructor. Used to handle special app states, like shutdown, app paused or resumed.
-  // Pass only if `syncManager` (used by NodeSignalListener) and `splitApi` (used by Browser listener) are passed.
-  SignalListener?: new (
-    syncManager: ISyncManager | undefined, // Used by NodeSignalListener to flush data, and by BrowserSignalListener to close streaming connection.
-    settings: ISettings, // Used by BrowserSignalListener
-    storage: IStorageSync | IStorageAsync, // Used by BrowserSignalListener
-    serviceApi: ISplitApi | undefined) => ISignalListener, // Used by BrowserSignalListener
-
   // @TODO review impressionListener and integrations interfaces. What about handling impressionListener as an integration ?
   integrationsManagerFactory?: (params: IIntegrationFactoryParams) => IIntegrationManager | undefined,
 

package/src/sdkManager/index.ts

@@ -1,16 +1,16 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { find } from '../utils/lang';
-import { validateSplit, validateSplitExistence, validateIfOperational } from '../utils/inputValidation';
+import { validateDefinition, validateDefinitionExistence, validateIfOperational } from '../utils/inputValidation';
 import { ISplitsCacheAsync, ISplitsCacheSync } from '../storages/types';
 import { ISdkReadinessManager } from '../readiness/types';
-import { ISplit } from '../dtos/types';
+import { IDefinition } from '../dtos/types';
 import { ISettings } from '../types';
 import SplitIO from '../../types/splitio';
 import { isConsumerMode } from '../utils/settingsValidation/mode';
 import { SPLIT_FN_LABEL, SPLITS_FN_LABEL, NAMES_FN_LABEL } from '../utils/constants';
 
-function collectTreatments(splitObject: ISplit) {
+function collectTreatments(splitObject: IDefinition) {
   const conditions = splitObject.conditions;
   // Rollout conditions are supposed to have the entire partitions list, so we find the first one.
   let allTreatmentsCondition = find(conditions, (cond) => cond.conditionType === 'ROLLOUT');
@@ -20,7 +20,7 @@ function collectTreatments(splitObject: ISplit) {
   return allTreatmentsCondition ? allTreatmentsCondition.partitions!.map(v => v.treatment) : [];
 }
 
-function objectToView(splitObject: ISplit | null): SplitIO.SplitView | null {
+function objectToView(splitObject: IDefinition | null): SplitIO.SplitView | null {
   if (!splitObject) return null;
 
   return {
@@ -29,7 +29,7 @@ function objectToView(splitObject: ISplit | null): SplitIO.SplitView | null {
     killed: splitObject.killed,
     changeNumber: splitObject.changeNumber || 0,
     treatments: collectTreatments(splitObject),
-    configs: splitObject.configurations || {},
+    configs: splitObject.configurations as SplitIO.SplitView['configs'] || {},
     sets: splitObject.sets || [],
     defaultTreatment: splitObject.defaultTreatment,
     impressionsDisabled: splitObject.impressionsDisabled === true,
@@ -37,7 +37,7 @@ function objectToView(splitObject: ISplit | null): SplitIO.SplitView | null {
   };
 }
 
-function objectsToViews(splitObjects: ISplit[]) {
+function objectsToViews(splitObjects: IDefinition[]) {
   let views: SplitIO.SplitView[] = [];
 
   splitObjects.forEach(split => {
@@ -65,7 +65,7 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
        * Get the feature flag object corresponding to the given feature flag name if valid
        */
       split(featureFlagName: string) {
-        const splitName = validateSplit(log, featureFlagName, SPLIT_FN_LABEL);
+        const splitName = validateDefinition(log, featureFlagName, SPLIT_FN_LABEL);
         if (!validateIfOperational(log, readinessManager, SPLIT_FN_LABEL) || !splitName) {
           return isAsync ? Promise.resolve(null) : null;
         }
@@ -74,12 +74,12 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
 
         if (thenable(split)) {
           return split.catch(() => null).then(result => { // handle possible rejections when using pluggable storage
-            validateSplitExistence(log, readinessManager, splitName, result, SPLIT_FN_LABEL);
+            validateDefinitionExistence(log, readinessManager, splitName, result, SPLIT_FN_LABEL);
             return objectToView(result);
           });
         }
 
-        validateSplitExistence(log, readinessManager, splitName, split, SPLIT_FN_LABEL);
+        validateDefinitionExistence(log, readinessManager, splitName, split, SPLIT_FN_LABEL);
 
         return objectToView(split);
       },

package/src/services/splitApi.ts

@@ -61,6 +61,12 @@ export function splitApiFactory(
         });
     },
 
+    // @TODO support filterQueryString and handle ERROR_TOO_MANY_SETS error
+    fetchConfigs(since: number, noCache?: boolean, till?: number) {
+      const url = `${urls.sdk}/v1/configs?since=${since}${filterQueryString || ''}${till ? '&till=' + till : ''}`;
+      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined);
+    },
+
     fetchSegmentChanges(since: number, segmentName: string, noCache?: boolean, till?: number) {
       const url = `${urls.sdk}/segmentChanges/${segmentName}?since=${since}${till ? '&till=' + till : ''}`;
       return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SEGMENT));

package/src/services/types.ts

@@ -35,7 +35,7 @@ export type ISplitHttpClient = (url: string, options?: IRequestOptions, latencyT
 
 export type IFetchAuth = (userKeys?: string[]) => Promise<IResponse>
 
-export type IFetchSplitChanges = (since: number, noCache?: boolean, till?: number, rbSince?: number) => Promise<IResponse>
+export type IFetchDefinitionChanges = (since: number, noCache?: boolean, till?: number, rbSince?: number) => Promise<IResponse>
 
 export type IFetchSegmentChanges = (since: number, segmentName: string, noCache?: boolean, till?: number) => Promise<IResponse>
 
@@ -59,7 +59,8 @@ export interface ISplitApi {
 	getSdkAPIHealthCheck: IHealthCheckAPI
 	getEventsAPIHealthCheck: IHealthCheckAPI
 	fetchAuth: IFetchAuth
-	fetchSplitChanges: IFetchSplitChanges
+	fetchSplitChanges: IFetchDefinitionChanges
+	fetchConfigs: IFetchDefinitionChanges
 	fetchSegmentChanges: IFetchSegmentChanges
 	fetchMemberships: IFetchMemberships
 	postEventsBulk: IPostEventsBulk

package/src/storages/AbstractSplitsCacheAsync.ts

@@ -1,5 +1,5 @@
 import { ISplitsCacheAsync } from './types';
-import { ISplit } from '../dtos/types';
+import { IDefinition } from '../dtos/types';
 import { objectAssign } from '../utils/lang/objectAssign';
 
 /**
@@ -8,24 +8,24 @@ import { objectAssign } from '../utils/lang/objectAssign';
  */
 export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
 
-  protected abstract addSplit(split: ISplit): Promise<boolean>
+  protected abstract addSplit(split: IDefinition): Promise<boolean>
   protected abstract removeSplit(name: string): Promise<boolean>
   protected abstract setChangeNumber(changeNumber: number): Promise<boolean | void>
 
-  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): Promise<boolean> {
+  update(toAdd: IDefinition[], toRemove: string[], changeNumber: number): Promise<boolean> {
     return Promise.all([
       this.setChangeNumber(changeNumber),
       Promise.all(toAdd.map(addedFF => this.addSplit(addedFF))),
-      Promise.all(toRemove.map(removedFF => this.removeSplit(removedFF.name)))
+      Promise.all(toRemove.map(removedFF => this.removeSplit(removedFF)))
     ]).then(([, added, removed]) => {
       return added.some(result => result) || removed.some(result => result);
     });
   }
 
-  abstract getSplit(name: string): Promise<ISplit | null>
-  abstract getSplits(names: string[]): Promise<Record<string, ISplit | null>>
+  abstract getSplit(name: string): Promise<IDefinition | null>
+  abstract getSplits(names: string[]): Promise<Record<string, IDefinition | null>>
   abstract getChangeNumber(): Promise<number>
-  abstract getAll(): Promise<ISplit[]>
+  abstract getAll(): Promise<IDefinition[]>
   abstract getSplitNames(): Promise<string[]>
   abstract getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]>
   abstract trafficTypeExists(trafficType: string): Promise<boolean>

package/src/storages/AbstractSplitsCacheSync.ts

@@ -1,5 +1,5 @@
 import { ISplitsCacheSync, IStorageSync } from './types';
-import { IRBSegment, ISplit } from '../dtos/types';
+import { IRBSegment, IDefinition } from '../dtos/types';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { IN_SEGMENT, IN_LARGE_SEGMENT } from '../utils/constants';
 
@@ -9,21 +9,21 @@ import { IN_SEGMENT, IN_LARGE_SEGMENT } from '../utils/constants';
  */
 export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
 
-  protected abstract addSplit(split: ISplit): boolean
+  protected abstract addSplit(split: IDefinition): boolean
   protected abstract removeSplit(name: string): boolean
   protected abstract setChangeNumber(changeNumber: number): boolean | void
 
-  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): boolean {
+  update(toAdd: IDefinition[], toRemove: string[], changeNumber: number): boolean {
     let updated = toAdd.map(addedFF => this.addSplit(addedFF)).some(result => result);
-    updated = toRemove.map(removedFF => this.removeSplit(removedFF.name)).some(result => result) || updated;
+    updated = toRemove.map(removedFF => this.removeSplit(removedFF)).some(result => result) || updated;
     this.setChangeNumber(changeNumber);
     return updated;
   }
 
-  abstract getSplit(name: string): ISplit | null
+  abstract getSplit(name: string): IDefinition | null
 
-  getSplits(names: string[]): Record<string, ISplit | null> {
-    const splits: Record<string, ISplit | null> = {};
+  getSplits(names: string[]): Record<string, IDefinition | null> {
+    const splits: Record<string, IDefinition | null> = {};
     names.forEach(name => {
       splits[name] = this.getSplit(name);
     });
@@ -32,8 +32,8 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
 
   abstract getChangeNumber(): number
 
-  getAll(): ISplit[] {
-    return this.getSplitNames().map(key => this.getSplit(key) as ISplit);
+  getAll(): IDefinition[] {
+    return this.getSplitNames().map(key => this.getSplit(key) as IDefinition);
   }
 
   abstract getSplitNames(): string[]
@@ -73,7 +73,7 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
  * Given a parsed split, it returns a boolean flagging if its conditions use segments matchers (rules & whitelists).
  * This util is intended to simplify the implementation of `splitsCache::usesSegments` method
  */
-export function usesSegments(ruleEntity: ISplit | IRBSegment) {
+export function usesSegments(ruleEntity: IDefinition | IRBSegment) {
   const conditions = ruleEntity.conditions || [];
   for (let i = 0; i < conditions.length; i++) {
     const matchers = conditions[i].matcherGroup.matchers;

package/src/storages/inLocalStorage/RBSegmentsCacheInLocal.ts

@@ -25,9 +25,9 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
     this.storage.removeItem(this.keys.buildRBSegmentsTillKey());
   }
 
-  update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): boolean {
+  update(toAdd: IRBSegment[], toRemove: string[], changeNumber: number): boolean {
     let updated = toAdd.map(toAdd => this.add(toAdd)).some(result => result);
-    updated = toRemove.map(toRemove => this.remove(toRemove.name)).some(result => result) || updated;
+    updated = toRemove.map(toRemove => this.remove(toRemove)).some(result => result) || updated;
     this.setChangeNumber(changeNumber);
     return updated;
   }

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -1,4 +1,4 @@
-import { ISplit } from '../../dtos/types';
+import { IDefinition } from '../../dtos/types';
 import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
 import { KeyBuilderCS } from '../KeyBuilderCS';
@@ -30,7 +30,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     else this.storage.removeItem(key);
   }
 
-  private _decrementCounts(split: ISplit) {
+  private _decrementCounts(split: IDefinition) {
     try {
       const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
       this._decrementCount(ttKey);
@@ -44,7 +44,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     }
   }
 
-  private _incrementCounts(split: ISplit) {
+  private _incrementCounts(split: IDefinition) {
     try {
       const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
       this.storage.setItem(ttKey, (toNumber(this.storage.getItem(ttKey)) + 1) + '');
@@ -79,7 +79,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     this.hasSync = false;
   }
 
-  addSplit(split: ISplit) {
+  addSplit(split: IDefinition) {
     const name = split.name;
     const splitKey = this.keys.buildSplitKey(name);
     const splitFromStorage = this.storage.getItem(splitKey);
@@ -110,7 +110,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     return true;
   }
 
-  getSplit(name: string): ISplit | null {
+  getSplit(name: string): IDefinition | null {
     const item = this.storage.getItem(this.keys.buildSplitKey(name));
     return item && JSON.parse(item);
   }
@@ -184,7 +184,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     });
   }
 
-  private addToFlagSets(featureFlag: ISplit) {
+  private addToFlagSets(featureFlag: IDefinition) {
     if (!featureFlag.sets) return;
 
     featureFlag.sets.forEach(featureFlagSet => {

package/src/storages/inMemory/RBSegmentsCacheInMemory.ts

@@ -15,9 +15,9 @@ export class RBSegmentsCacheInMemory implements IRBSegmentsCacheSync {
     this.segmentsCount = 0;
   }
 
-  update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): boolean {
+  update(toAdd: IRBSegment[], toRemove: string[], changeNumber: number): boolean {
     let updated = toAdd.map(toAdd => this.add(toAdd)).some(result => result);
-    updated = toRemove.map(toRemove => this.remove(toRemove.name)).some(result => result) || updated;
+    updated = toRemove.map(toRemove => this.remove(toRemove)).some(result => result) || updated;
     this.changeNumber = changeNumber;
     return updated;
   }

package/src/storages/inMemory/SplitsCacheInMemory.ts

@@ -1,4 +1,4 @@
-import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
+import { IDefinition, ISplitFiltersValidation } from '../../dtos/types';
 import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber } from '../../utils/lang';
 
@@ -8,7 +8,7 @@ import { isFiniteNumber } from '../../utils/lang';
 export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
 
   private flagSetsFilter: string[];
-  private splitsCache: Record<string, ISplit> = {};
+  private splitsCache: Record<string, IDefinition> = {};
   private ttCache: Record<string, number> = {};
   private changeNumber: number = -1;
   private segmentsCount: number = 0;
@@ -27,7 +27,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     this.flagSetsCache = {};
   }
 
-  addSplit(split: ISplit): boolean {
+  addSplit(split: IDefinition): boolean {
     const name = split.name;
     const previousSplit = this.getSplit(name);
     if (previousSplit) { // We had this Split already
@@ -73,7 +73,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     return true;
   }
 
-  getSplit(name: string): ISplit | null {
+  getSplit(name: string): IDefinition | null {
     return this.splitsCache[name] || null;
   }
 
@@ -102,7 +102,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     return flagSets.map(flagSet => this.flagSetsCache[flagSet] || new Set());
   }
 
-  private addToFlagSets(featureFlag: ISplit) {
+  private addToFlagSets(featureFlag: IDefinition) {
     if (!featureFlag.sets) return;
     featureFlag.sets.forEach(featureFlagSet => {
 

package/src/storages/inMemory/TelemetryCacheInMemory.ts

@@ -20,8 +20,8 @@ const ACCEPTANCE_RANGE = 0.001;
  * Record telemetry if mode is not localhost.
  * All factory instances track telemetry on server-side, and 0.1% on client-side.
  */
-export function shouldRecordTelemetry({ settings }: IStorageFactoryParams) {
-  return settings.mode !== LOCALHOST_MODE && (checkIfServerSide(settings) || Math.random() <= ACCEPTANCE_RANGE);
+export function shouldRecordTelemetry({ settings, disableTelemetry }: IStorageFactoryParams) {
+  return !disableTelemetry && settings.mode !== LOCALHOST_MODE && (checkIfServerSide(settings) || Math.random() <= ACCEPTANCE_RANGE);
 }
 
 export class TelemetryCacheInMemory implements ITelemetryCacheSync {

package/src/storages/inRedis/RBSegmentsCacheInRedis.ts

@@ -37,7 +37,7 @@ export class RBSegmentsCacheInRedis implements IRBSegmentsCacheAsync {
     });
   }
 
-  update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): Promise<boolean> {
+  update(toAdd: IRBSegment[], toRemove: string[], changeNumber: number): Promise<boolean> {
     return Promise.all([
       this.setChangeNumber(changeNumber),
       Promise.all(toAdd.map(toAdd => {
@@ -46,7 +46,7 @@ export class RBSegmentsCacheInRedis implements IRBSegmentsCacheAsync {
         return this.redis.set(key, stringifiedNewRBSegment).then(() => true);
       })),
       Promise.all(toRemove.map(toRemove => {
-        const key = this.keys.buildRBSegmentKey(toRemove.name);
+        const key = this.keys.buildRBSegmentKey(toRemove);
         return this.redis.del(key).then((status: number) => status === 1);
       }))
     ]).then(([, added, removed]) => {

package/src/storages/inRedis/SplitsCacheInRedis.ts

@@ -2,7 +2,7 @@ import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
-import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
+import { IDefinition, ISplitFiltersValidation } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
 import { returnDifference } from '../../utils/lang/sets';
 import type { RedisAdapter } from './RedisAdapter';
@@ -47,14 +47,14 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
     });
   }
 
-  private _decrementCounts(split: ISplit) {
+  private _decrementCounts(split: IDefinition) {
     const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
     return this.redis.decr(ttKey).then((count: number) => {
       if (count === 0) return this.redis.del(ttKey);
     });
   }
 
-  private _incrementCounts(split: ISplit) {
+  private _incrementCounts(split: IDefinition) {
     const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
     return this.redis.incr(ttKey);
   }
@@ -82,13 +82,13 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    * The returned promise is resolved when the operation success
    * or rejected if it fails (e.g., redis operation fails)
    */
-  addSplit(split: ISplit): Promise<boolean> {
+  addSplit(split: IDefinition): Promise<boolean> {
     const name = split.name;
     const splitKey = this.keys.buildSplitKey(name);
     return this.redis.get(splitKey).then((splitFromStorage: string | null) => {
 
       // handling parsing error
-      let parsedPreviousSplit: ISplit, stringifiedNewSplit;
+      let parsedPreviousSplit: IDefinition, stringifiedNewSplit;
       try {
         parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
         stringifiedNewSplit = JSON.stringify(split);
@@ -127,7 +127,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    * Get split definition or null if it's not defined.
    * Returned promise is rejected if redis operation fails.
    */
-  getSplit(name: string): Promise<ISplit | null> {
+  getSplit(name: string): Promise<IDefinition | null> {
     if (this.redisError) {
       this.log.error(LOG_PREFIX + this.redisError);
 
@@ -171,7 +171,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    * or rejected if redis operation fails.
    */
   // @TODO we need to benchmark which is the maximun number of commands we could pipeline without kill redis performance.
-  getAll(): Promise<ISplit[]> {
+  getAll(): Promise<IDefinition[]> {
     return this.redis.keys(this.keys.searchPatternForSplitKeys())
       .then((listOfKeys: string[]) => this.redis.pipeline(listOfKeys.map((k: string) => ['get', k])).exec())
       .then(processPipelineAnswer)
@@ -242,7 +242,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    * Fetches multiple splits definitions.
    * Returned promise is rejected if redis operation fails.
    */
-  getSplits(names: string[]): Promise<Record<string, ISplit | null>> {
+  getSplits(names: string[]): Promise<Record<string, IDefinition | null>> {
     if (this.redisError) {
       this.log.error(LOG_PREFIX + this.redisError);
 
@@ -252,7 +252,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
     const keys = names.map(name => this.keys.buildSplitKey(name));
     return this.redis.mget(...keys)
       .then((splitDefinitions: (string | null)[]) => {
-        const splits: Record<string, ISplit | null> = {};
+        const splits: Record<string, IDefinition | null> = {};
         names.forEach((name, idx) => {
           const split = splitDefinitions[idx];
           splits[name] = split && JSON.parse(split);

package/src/storages/pluggable/RBSegmentsCachePluggable.ts

@@ -36,7 +36,7 @@ export class RBSegmentsCachePluggable implements IRBSegmentsCacheAsync {
     });
   }
 
-  update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): Promise<boolean> {
+  update(toAdd: IRBSegment[], toRemove: string[], changeNumber: number): Promise<boolean> {
     return Promise.all([
       this.setChangeNumber(changeNumber),
       Promise.all(toAdd.map(toAdd => {
@@ -45,7 +45,7 @@ export class RBSegmentsCachePluggable implements IRBSegmentsCacheAsync {
         return this.wrapper.set(key, stringifiedNewRBSegment).then(() => true);
       })),
       Promise.all(toRemove.map(toRemove => {
-        const key = this.keys.buildRBSegmentKey(toRemove.name);
+        const key = this.keys.buildRBSegmentKey(toRemove);
         return this.wrapper.del(key);
       }))
     ]).then(([, added, removed]) => {