@splitsoftware/splitio-commons 1.9.2-rc.1 → 1.9.2

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -4,7 +4,6 @@ import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
 import { KeyBuilderCS } from '../KeyBuilderCS';
 import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
-import { ISet, _Set, returnSetsUnion, setToArray } from '../../utils/lang/sets';
 
 /**
  * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
@@ -13,8 +12,8 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
 
   private readonly keys: KeyBuilderCS;
   private readonly splitFiltersValidation: ISplitFiltersValidation;
-  private readonly flagSetsFilter: string[];
   private hasSync?: boolean;
+  private cacheReadyButNeedsToFlush: boolean = false;
   private updateNewFilter?: boolean;
 
   /**
@@ -22,11 +21,10 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
    * @param {number | undefined} expirationTimestamp
    * @param {ISplitFiltersValidation} splitFiltersValidation
    */
-  constructor(private readonly log: ILogger, keys: KeyBuilderCS, expirationTimestamp?: number, splitFiltersValidation: ISplitFiltersValidation = { queryString: null, groupedFilters: { bySet: [], byName: [], byPrefix: [] }, validFilters: [] }) {
+  constructor(private readonly log: ILogger, keys: KeyBuilderCS, expirationTimestamp?: number, splitFiltersValidation: ISplitFiltersValidation = { queryString: null, groupedFilters: { byName: [], byPrefix: [] }, validFilters: [] }) {
     super();
     this.keys = keys;
     this.splitFiltersValidation = splitFiltersValidation;
-    this.flagSetsFilter = this.splitFiltersValidation.groupedFilters.bySet;
 
     this._checkExpiration(expirationTimestamp);
 
@@ -108,9 +106,6 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
       this._incrementCounts(split);
       this._decrementCounts(previousSplit);
 
-      if (previousSplit) this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
-      this.addToFlagSets(split);
-
       return true;
     } catch (e) {
       this.log.error(LOG_PREFIX + e);
@@ -124,7 +119,6 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
       localStorage.removeItem(this.keys.buildSplitKey(name));
 
       this._decrementCounts(split);
-      if (split) this.removeFromFlagSets(split.name, split.sets);
 
       return true;
     } catch (e) {
@@ -139,6 +133,11 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   }
 
   setChangeNumber(changeNumber: number): boolean {
+    // when cache is ready but using a new split query, we must clear all split data
+    if (this.cacheReadyButNeedsToFlush) {
+      this.clear();
+      this.cacheReadyButNeedsToFlush = false;
+    }
 
     // when using a new split query, we must update it at the store
     if (this.updateNewFilter) {
@@ -221,7 +220,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
    * @override
    */
   checkCache(): boolean {
-    return this.getChangeNumber() > -1;
+    return this.getChangeNumber() > -1 || this.cacheReadyButNeedsToFlush;
   }
 
   /**
@@ -238,7 +237,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   }
 
   private _checkFilterQuery() {
-    const { queryString } = this.splitFiltersValidation;
+    const { queryString, groupedFilters } = this.splitFiltersValidation;
     const queryKey = this.keys.buildSplitsFilterQueryKey();
     const currentQueryString = localStorage.getItem(queryKey);
 
@@ -247,74 +246,29 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
         // mark cache to update the new query filter on first successful splits fetch
         this.updateNewFilter = true;
 
-        // if there is cache, clear it
-        if (this.checkCache()) this.clear();
-
+        // if cache is ready:
+        if (this.checkCache()) {
+          // * set change number to -1, to fetch splits with -1 `since` value.
+          localStorage.setItem(this.keys.buildSplitsTillKey(), '-1');
+
+          // * remove from cache splits that doesn't match with the new filters
+          this.getSplitNames().forEach((splitName) => {
+            if (queryString && (
+              // @TODO consider redefining `groupedFilters` to expose a method like `groupedFilters::filter(splitName): boolean`
+              groupedFilters.byName.indexOf(splitName) > -1 ||
+              groupedFilters.byPrefix.some((prefix: string) => splitName.startsWith(prefix + '__'))
+            )) {
+              // * set `cacheReadyButNeedsToFlush` so that `checkCache` returns true (the storage is ready to be used) and the data is cleared before updating on first successful splits fetch
+              this.cacheReadyButNeedsToFlush = true;
+              return;
+            }
+            this.removeSplit(splitName);
+          });
+        }
       } catch (e) {
         this.log.error(LOG_PREFIX + e);
       }
     }
     // if the filter didn't change, nothing is done
   }
-
-  getNamesByFlagSets(flagSets: string[]): ISet<string>{
-    let toReturn: ISet<string> = new _Set([]);
-    flagSets.forEach(flagSet => {
-      const flagSetKey = this.keys.buildFlagSetKey(flagSet);
-      let flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
-
-      if (flagSetFromLocalStorage) {
-        const flagSetCache = new _Set(JSON.parse(flagSetFromLocalStorage));
-        toReturn = returnSetsUnion(toReturn, flagSetCache);
-      }
-    });
-    return toReturn;
-
-  }
-
-  private addToFlagSets(featureFlag: ISplit) {
-    if (!featureFlag.sets) return;
-
-    featureFlag.sets.forEach(featureFlagSet => {
-
-      if (this.flagSetsFilter.length > 0 && !this.flagSetsFilter.some(filterFlagSet => filterFlagSet === featureFlagSet)) return;
-
-      const flagSetKey = this.keys.buildFlagSetKey(featureFlagSet);
-
-      let flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
-      if (!flagSetFromLocalStorage) flagSetFromLocalStorage = '[]';
-
-      const flagSetCache = new _Set(JSON.parse(flagSetFromLocalStorage));
-      flagSetCache.add(featureFlag.name);
-
-      localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
-    });
-  }
-
-  private removeFromFlagSets(featureFlagName: string, flagSets?: string[]) {
-    if (!flagSets) return;
-
-    flagSets.forEach(flagSet => {
-      this.removeNames(flagSet, featureFlagName);
-    });
-  }
-
-  private removeNames(flagSetName: string, featureFlagName: string) {
-    const flagSetKey = this.keys.buildFlagSetKey(flagSetName);
-
-    let flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
-
-    if (!flagSetFromLocalStorage) return;
-
-    const flagSetCache = new _Set(JSON.parse(flagSetFromLocalStorage));
-    flagSetCache.delete(featureFlagName);
-
-    if (flagSetCache.size === 0) {
-      localStorage.removeItem(flagSetKey);
-      return;
-    }
-
-    localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
-  }
-
 }

package/src/storages/inLocalStorage/index.ts

@@ -54,7 +54,7 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
       uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
 
       destroy() {
-        this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
+        this.splits = new SplitsCacheInMemory();
         this.segments = new MySegmentsCacheInMemory();
         this.impressions.clear();
         this.impressionCounts && this.impressionCounts.clear();
@@ -75,7 +75,7 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
           telemetry: this.telemetry,
 
           destroy() {
-            this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
+            this.splits = new SplitsCacheInMemory();
             this.segments = new MySegmentsCacheInMemory();
           }
         };

package/src/storages/inMemory/InMemoryStorage.ts

@@ -14,9 +14,9 @@ import { UniqueKeysCacheInMemory } from './UniqueKeysCacheInMemory';
  * @param params parameters required by EventsCacheSync
  */
 export function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageSync {
-  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation } } } = params;
+  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode } } } = params;
 
-  const splits = new SplitsCacheInMemory(__splitFiltersValidation);
+  const splits = new SplitsCacheInMemory();
   const segments = new SegmentsCacheInMemory();
 
   const storage = {

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -14,9 +14,9 @@ import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
  * @param params parameters required by EventsCacheSync
  */
 export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorageSync {
-  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation } } } = params;
+  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode } } } = params;
 
-  const splits = new SplitsCacheInMemory(__splitFiltersValidation);
+  const splits = new SplitsCacheInMemory();
   const segments = new MySegmentsCacheInMemory();
 
   const storage = {
@@ -50,7 +50,7 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
 
         // Set a new splits cache to clean it for the client without affecting other clients
         destroy() {
-          this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
+          this.splits = new SplitsCacheInMemory();
           this.segments.clear();
         }
       };

package/src/storages/inMemory/SplitsCacheInMemory.ts

@@ -1,7 +1,6 @@
-import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
+import { ISplit } from '../../dtos/types';
 import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber } from '../../utils/lang';
-import { ISet, _Set, returnSetsUnion } from '../../utils/lang/sets';
 
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
@@ -9,17 +8,10 @@ import { ISet, _Set, returnSetsUnion } from '../../utils/lang/sets';
  */
 export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
 
-  private flagSetsFilter: string[];
   private splitsCache: Record<string, ISplit> = {};
   private ttCache: Record<string, number> = {};
   private changeNumber: number = -1;
   private splitsWithSegmentsCount: number = 0;
-  private flagSetsCache: Record<string, ISet<string>> = {};
-
-  constructor(splitFiltersValidation: ISplitFiltersValidation = { queryString: null, groupedFilters: { bySet: [], byName: [], byPrefix: [] }, validFilters: [] }) {
-    super();
-    this.flagSetsFilter = splitFiltersValidation.groupedFilters.bySet;
-  }
 
   clear() {
     this.splitsCache = {};
@@ -36,8 +28,6 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       this.ttCache[previousTtName]--;
       if (!this.ttCache[previousTtName]) delete this.ttCache[previousTtName];
 
-      this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
-
       if (usesSegments(previousSplit)) { // Substract from segments count for the previous version of this Split.
         this.splitsWithSegmentsCount--;
       }
@@ -49,7 +39,6 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       // Update TT cache
       const ttName = split.trafficTypeName;
       this.ttCache[ttName] = (this.ttCache[ttName] || 0) + 1;
-      this.addToFlagSets(split);
 
       // Add to segments count for the new version of the Split
       if (usesSegments(split)) this.splitsWithSegmentsCount++;
@@ -69,7 +58,6 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       const ttName = split.trafficTypeName;
       this.ttCache[ttName]--; // Update tt cache
       if (!this.ttCache[ttName]) delete this.ttCache[ttName];
-      this.removeFromFlagSets(split.name, split.sets);
 
       // Update the segments count.
       if (usesSegments(split)) this.splitsWithSegmentsCount--;
@@ -105,41 +93,4 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     return this.getChangeNumber() === -1 || this.splitsWithSegmentsCount > 0;
   }
 
-  getNamesByFlagSets(flagSets: string[]): ISet<string>{
-    let toReturn: ISet<string> = new _Set([]);
-    flagSets.forEach(flagSet => {
-      const featureFlagNames = this.flagSetsCache[flagSet];
-      if (featureFlagNames) {
-        toReturn = returnSetsUnion(toReturn, featureFlagNames);
-      }
-    });
-    return toReturn;
-
-  }
-
-  private addToFlagSets(featureFlag: ISplit) {
-    if (!featureFlag.sets) return;
-    featureFlag.sets.forEach(featureFlagSet => {
-
-      if (this.flagSetsFilter.length > 0 && !this.flagSetsFilter.some(filterFlagSet => filterFlagSet === featureFlagSet)) return;
-
-      if (!this.flagSetsCache[featureFlagSet]) this.flagSetsCache[featureFlagSet] = new _Set([]);
-
-      this.flagSetsCache[featureFlagSet].add(featureFlag.name);
-    });
-  }
-
-  private removeFromFlagSets(featureFlagName :string, flagSets: string[] | undefined) {
-    if (!flagSets) return;
-    flagSets.forEach(flagSet => {
-      this.removeNames(flagSet, featureFlagName);
-    });
-  }
-
-  private removeNames(flagSetName: string, featureFlagName: string) {
-    if (!this.flagSetsCache[flagSetName]) return;
-    this.flagSetsCache[flagSetName].delete(featureFlagName);
-    if (this.flagSetsCache[flagSetName].size === 0) delete this.flagSetsCache[flagSetName];
-  }
-
 }

package/src/storages/inRedis/SplitsCacheInRedis.ts

@@ -5,7 +5,6 @@ import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
 import { ISplit } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { ISet, _Set } from '../../utils/lang/sets';
 
 /**
  * Discard errors for an answer of multiple operations.
@@ -189,17 +188,6 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
     );
   }
 
-  /**
-   * Get list of split names related to a given flag set names list.
-   * The returned promise is resolved with the list of split names,
-   * or rejected if wrapper operation fails.
-   * @todo this is a no-op method to be implemented
-  */
-  getNamesByFlagSets(): Promise<ISet<string>> {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    return new Promise(flagSets => new _Set([]));
-  }
-
   /**
    * Check traffic type existence.
    * The returned promise is resolved with a boolean indicating whether the TT exist or not.

package/src/storages/pluggable/SplitsCachePluggable.ts

@@ -5,7 +5,6 @@ import { ILogger } from '../../logger/types';
 import { ISplit } from '../../dtos/types';
 import { LOG_PREFIX } from './constants';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { ISet, _Set } from '../../utils/lang/sets';
 
 /**
  * ISplitsCacheAsync implementation for pluggable storages.
@@ -155,17 +154,6 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
     );
   }
 
-  /**
-   * Get list of split names related to a given flag set names list.
-   * The returned promise is resolved with the list of split names,
-   * or rejected if wrapper operation fails.
-   * @todo this is a no-op method to be implemented
-  */
-  getNamesByFlagSets(): Promise<ISet<string>> {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    return new Promise(flagSets => new _Set([]));
-  }
-
   /**
    * Check traffic type existence.
    * The returned promise is resolved with a boolean indicating whether the TT exist or not.

package/src/storages/types.ts

@@ -1,7 +1,6 @@
 import { MaybeThenable, ISplit } from '../dtos/types';
 import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs, TelemetryUsageStatsPayload, UpdatesFromSSEEnum } from '../sync/submitters/types';
 import { SplitIO, ImpressionDTO, ISettings } from '../types';
-import { ISet } from '../utils/lang/sets';
 
 /**
  * Interface of a pluggable storage wrapper.
@@ -209,8 +208,7 @@ export interface ISplitsCacheBase {
   clear(): MaybeThenable<boolean | void>,
   // should never reject or throw an exception. Instead return false by default, to avoid emitting SDK_READY_FROM_CACHE.
   checkCache(): MaybeThenable<boolean>,
-  killLocally(name: string, defaultTreatment: string, changeNumber: number): MaybeThenable<boolean>,
-  getNamesByFlagSets(flagSets: string[]): MaybeThenable<ISet<string>>
+  killLocally(name: string, defaultTreatment: string, changeNumber: number): MaybeThenable<boolean>
 }
 
 export interface ISplitsCacheSync extends ISplitsCacheBase {
@@ -226,8 +224,7 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
   usesSegments(): boolean,
   clear(): void,
   checkCache(): boolean,
-  killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean,
-  getNamesByFlagSets(flagSets: string[]): ISet<string>
+  killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean
 }
 
 export interface ISplitsCacheAsync extends ISplitsCacheBase {
@@ -243,8 +240,7 @@ export interface ISplitsCacheAsync extends ISplitsCacheBase {
   usesSegments(): Promise<boolean>,
   clear(): Promise<boolean | void>,
   checkCache(): Promise<boolean>,
-  killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>,
-  getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>>
+  killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>
 }
 
 /** Segments cache */

package/src/sync/polling/syncTasks/splitsSyncTask.ts

@@ -24,7 +24,6 @@ export function splitsSyncTaskFactory(
       splitChangesFetcherFactory(fetchSplitChanges),
       storage.splits,
       storage.segments,
-      settings.sync.__splitFiltersValidation,
       readiness.splits,
       settings.startup.requestTimeoutBeforeReady,
       settings.startup.retriesOnFailureBeforeReady,

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

@@ -1,13 +1,12 @@
 import { _Set, setToArray, ISet } from '../../../utils/lang/sets';
 import { ISegmentsCacheBase, ISplitsCacheBase } from '../../../storages/types';
 import { ISplitChangesFetcher } from '../fetchers/types';
-import { ISplit, ISplitChangesResponse, ISplitFiltersValidation } from '../../../dtos/types';
+import { ISplit, ISplitChangesResponse } from '../../../dtos/types';
 import { ISplitsEventEmitter } from '../../../readiness/types';
 import { timeout } from '../../../utils/promise/timeout';
 import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
 import { SYNC_SPLITS_FETCH, SYNC_SPLITS_NEW, SYNC_SPLITS_REMOVED, SYNC_SPLITS_SEGMENTS, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
-import { startsWith } from '../../../utils/lang';
 
 type ISplitChangesUpdater = (noCache?: boolean, till?: number, splitUpdateNotification?: { payload: ISplit, changeNumber: number }) => Promise<boolean>
 
@@ -46,36 +45,15 @@ interface ISplitMutations {
   segments: string[]
 }
 
-/**
- * If there are defined filters and one feature flag doesn't match with them, its status is changed to 'ARCHIVE' to avoid storing it
- * If there are set filter defined, names filter is ignored
- *
- * @param featureFlag feature flag to be evaluated
- * @param filters splitFiltersValidation bySet | byName
- */
-function matchFilters(featureFlag: ISplit, filters: ISplitFiltersValidation) {
-  const { bySet: setsFilter, byName: namesFilter, byPrefix: prefixFilter} = filters.groupedFilters;
-  if (setsFilter.length > 0) return featureFlag.sets && featureFlag.sets.some((featureFlagSet: string) => setsFilter.indexOf(featureFlagSet) > -1);
-
-  const namesFilterConfigured = namesFilter.length > 0;
-  const prefixFilterConfigured = prefixFilter.length > 0;
-
-  if (!namesFilterConfigured && !prefixFilterConfigured) return true;
-
-  const matchNames = namesFilterConfigured && namesFilter.indexOf(featureFlag.name) > -1;
-  const matchPrefix = prefixFilterConfigured && prefixFilter.some(prefix => startsWith(featureFlag.name, prefix));
-  return matchNames || matchPrefix;
-}
-
 /**
  * Given the list of splits from /splitChanges endpoint, it returns the mutations,
  * i.e., an object with added splits, removed splits and used segments.
  * Exported for testing purposes.
  */
-export function computeSplitsMutation(entries: ISplit[], filters: ISplitFiltersValidation): ISplitMutations {
+export function computeSplitsMutation(entries: ISplit[]): ISplitMutations {
   const segments = new _Set<string>();
   const computed = entries.reduce((accum, split) => {
-    if (split.status === 'ACTIVE' && matchFilters(split, filters)) {
+    if (split.status === 'ACTIVE') {
       accum.added.push([split.name, split]);
 
       parseSegments(split).forEach((segmentName: string) => {
@@ -112,7 +90,6 @@ export function splitChangesUpdaterFactory(
   splitChangesFetcher: ISplitChangesFetcher,
   splits: ISplitsCacheBase,
   segments: ISegmentsCacheBase,
-  splitFiltersValidation: ISplitFiltersValidation,
   splitsEventEmitter?: ISplitsEventEmitter,
   requestTimeoutBeforeReady: number = 0,
   retriesOnFailureBeforeReady: number = 0,
@@ -149,7 +126,7 @@ export function splitChangesUpdaterFactory(
         .then((splitChanges: ISplitChangesResponse) => {
           startingUp = false;
 
-          const mutation = computeSplitsMutation(splitChanges.splits, splitFiltersValidation);
+          const mutation = computeSplitsMutation(splitChanges.splits);
 
           log.debug(SYNC_SPLITS_NEW, [mutation.added.length]);
           log.debug(SYNC_SPLITS_REMOVED, [mutation.removed.length]);

package/src/sync/submitters/telemetrySubmitter.ts

@@ -3,13 +3,12 @@ import { submitterFactory, firstPushWindowDecorator } from './submitter';
 import { TelemetryConfigStatsPayload, TelemetryConfigStats } from './types';
 import { 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, SplitIO } 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';
-import { ISplitFiltersValidation } from '../../dtos/types';
 
 const OPERATION_MODE_MAP = {
   [STANDALONE_MODE]: STANDALONE_ENUM,
@@ -39,18 +38,6 @@ function getRedundantActiveFactories() {
   }, 0);
 }
 
-function getTelemetryFlagSetsStats(splitFiltersValidation: ISplitFiltersValidation) {
-  // Group every configured flag set in an unique array called originalSets
-  let flagSetsTotal = 0;
-  splitFiltersValidation.validFilters.forEach((filter: SplitIO.SplitFilter) => {
-    if (filter.type === 'bySet') flagSetsTotal += filter.values.length;
-  });
-
-  const flagSetsValid = splitFiltersValidation.groupedFilters.bySet.length;
-  const flagSetsIgnored = flagSetsTotal - flagSetsValid;
-  return { flagSetsTotal, flagSetsIgnored };
-}
-
 export function getTelemetryConfigStats(mode: SDKMode, storageType: string): TelemetryConfigStats {
   return {
     oM: OPERATION_MODE_MAP[mode], // @ts-ignore lower case of storage type
@@ -72,8 +59,6 @@ export function telemetryCacheConfigAdapter(telemetry: ITelemetryCacheSync, sett
       const { urls, scheduler } = settings;
       const isClientSide = settings.core.key !== undefined;
 
-      const { flagSetsTotal, flagSetsIgnored } = getTelemetryFlagSetsStats(settings.sync.__splitFiltersValidation);
-
       return objectAssign(getTelemetryConfigStats(settings.mode, settings.storage.type), {
         sE: settings.streamingEnabled,
         rR: {
@@ -101,9 +86,7 @@ export function telemetryCacheConfigAdapter(telemetry: ITelemetryCacheSync, sett
         nR: telemetry.getNonReadyUsage(),
         t: telemetry.popTags(),
         i: settings.integrations && settings.integrations.map(int => int.type),
-        uC: settings.userConsent ? USER_CONSENT_MAP[settings.userConsent] : 0,
-        fsT: flagSetsTotal,
-        fsI: flagSetsIgnored
+        uC: settings.userConsent ? USER_CONSENT_MAP[settings.userConsent] : 0
       });
     }
   };

package/src/sync/submitters/types.ts

@@ -124,11 +124,7 @@ export type TREATMENTS = 'ts';
 export type TREATMENT_WITH_CONFIG = 'tc';
 export type TREATMENTS_WITH_CONFIG = 'tcs';
 export type TRACK = 'tr';
-export type TREATMENTS_BY_FLAGSET = 'tf'
-export type TREATMENTS_BY_FLAGSETS = 'tfs'
-export type TREATMENTS_WITH_CONFIG_BY_FLAGSET = 'tcf'
-export type TREATMENTS_WITH_CONFIG_BY_FLAGSETS = 'tcfs'
-export type Method = TREATMENT | TREATMENTS | TREATMENT_WITH_CONFIG | TREATMENTS_WITH_CONFIG | TRACK | TREATMENTS_BY_FLAGSET | TREATMENTS_BY_FLAGSETS | TREATMENTS_WITH_CONFIG_BY_FLAGSET | TREATMENTS_WITH_CONFIG_BY_FLAGSETS;
+export type Method = TREATMENT | TREATMENTS | TREATMENT_WITH_CONFIG | TREATMENTS_WITH_CONFIG | TRACK;
 
 export type MethodLatencies = Partial<Record<Method, Array<number>>>;
 
@@ -238,8 +234,6 @@ export type TelemetryConfigStatsPayload = TelemetryConfigStats & {
   nR: number, // SDKNotReadyUsage
   i?: Array<string>, // integrations
   uC: number, // userConsent
-  fsT: number, // flagSetsTotal
-  fsI: number, // flagSetsInvalid
 }
 
 export interface ISubmitterManager extends ISyncTask {