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

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -4,6 +4,7 @@ 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.
@@ -12,8 +13,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;
 
   /**
@@ -21,10 +22,11 @@ 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: { byName: [], byPrefix: [] }, validFilters: [] }) {
+  constructor(private readonly log: ILogger, keys: KeyBuilderCS, expirationTimestamp?: number, splitFiltersValidation: ISplitFiltersValidation = { queryString: null, groupedFilters: { bySet: [], byName: [], byPrefix: [] }, validFilters: [] }) {
     super();
     this.keys = keys;
     this.splitFiltersValidation = splitFiltersValidation;
+    this.flagSetsFilter = this.splitFiltersValidation.groupedFilters.bySet;
 
     this._checkExpiration(expirationTimestamp);
 
@@ -106,6 +108,9 @@ 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);
@@ -119,6 +124,7 @@ 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) {
@@ -133,11 +139,6 @@ 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) {
@@ -220,7 +221,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
    * @override
    */
   checkCache(): boolean {
-    return this.getChangeNumber() > -1 || this.cacheReadyButNeedsToFlush;
+    return this.getChangeNumber() > -1;
   }
 
   /**
@@ -237,7 +238,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   }
 
   private _checkFilterQuery() {
-    const { queryString, groupedFilters } = this.splitFiltersValidation;
+    const { queryString } = this.splitFiltersValidation;
     const queryKey = this.keys.buildSplitsFilterQueryKey();
     const currentQueryString = localStorage.getItem(queryKey);
 
@@ -246,29 +247,74 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
         // mark cache to update the new query filter on first successful splits fetch
         this.updateNewFilter = true;
 
-        // 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);
-          });
-        }
+        // if there is cache, clear it
+        if (this.checkCache()) this.clear();
+
       } 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();
+        this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
         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();
+            this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
             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 } } } = params;
+  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation } } } = params;
 
-  const splits = new SplitsCacheInMemory();
+  const splits = new SplitsCacheInMemory(__splitFiltersValidation);
   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 } } } = params;
+  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation } } } = params;
 
-  const splits = new SplitsCacheInMemory();
+  const splits = new SplitsCacheInMemory(__splitFiltersValidation);
   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();
+          this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
           this.segments.clear();
         }
       };

package/src/storages/inMemory/SplitsCacheInMemory.ts

@@ -1,6 +1,7 @@
-import { ISplit } from '../../dtos/types';
+import { ISplit, ISplitFiltersValidation } 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.
@@ -8,10 +9,17 @@ import { isFiniteNumber } from '../../utils/lang';
  */
 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 = {};
@@ -28,6 +36,8 @@ 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--;
       }
@@ -39,6 +49,7 @@ 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++;
@@ -58,6 +69,7 @@ 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--;
@@ -93,4 +105,41 @@ 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,6 +5,7 @@ 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.
@@ -188,6 +189,17 @@ 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,6 +5,7 @@ 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.
@@ -154,6 +155,17 @@ 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,6 +1,7 @@
 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.
@@ -208,7 +209,8 @@ 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>
+  killLocally(name: string, defaultTreatment: string, changeNumber: number): MaybeThenable<boolean>,
+  getNamesByFlagSets(flagSets: string[]): MaybeThenable<ISet<string>>
 }
 
 export interface ISplitsCacheSync extends ISplitsCacheBase {
@@ -224,7 +226,8 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
   usesSegments(): boolean,
   clear(): void,
   checkCache(): boolean,
-  killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean
+  killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean,
+  getNamesByFlagSets(flagSets: string[]): ISet<string>
 }
 
 export interface ISplitsCacheAsync extends ISplitsCacheBase {
@@ -240,7 +243,8 @@ export interface ISplitsCacheAsync extends ISplitsCacheBase {
   usesSegments(): Promise<boolean>,
   clear(): Promise<boolean | void>,
   checkCache(): Promise<boolean>,
-  killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>
+  killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>,
+  getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>>
 }
 
 /** Segments cache */

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

@@ -24,6 +24,7 @@ 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,12 +1,13 @@
 import { _Set, setToArray, ISet } from '../../../utils/lang/sets';
 import { ISegmentsCacheBase, ISplitsCacheBase } from '../../../storages/types';
 import { ISplitChangesFetcher } from '../fetchers/types';
-import { ISplit, ISplitChangesResponse } from '../../../dtos/types';
+import { ISplit, ISplitChangesResponse, ISplitFiltersValidation } 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>
 
@@ -45,15 +46,36 @@ 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[]): ISplitMutations {
+export function computeSplitsMutation(entries: ISplit[], filters: ISplitFiltersValidation): ISplitMutations {
   const segments = new _Set<string>();
   const computed = entries.reduce((accum, split) => {
-    if (split.status === 'ACTIVE') {
+    if (split.status === 'ACTIVE' && matchFilters(split, filters)) {
       accum.added.push([split.name, split]);
 
       parseSegments(split).forEach((segmentName: string) => {
@@ -90,6 +112,7 @@ export function splitChangesUpdaterFactory(
   splitChangesFetcher: ISplitChangesFetcher,
   splits: ISplitsCacheBase,
   segments: ISegmentsCacheBase,
+  splitFiltersValidation: ISplitFiltersValidation,
   splitsEventEmitter?: ISplitsEventEmitter,
   requestTimeoutBeforeReady: number = 0,
   retriesOnFailureBeforeReady: number = 0,
@@ -126,7 +149,7 @@ export function splitChangesUpdaterFactory(
         .then((splitChanges: ISplitChangesResponse) => {
           startingUp = false;
 
-          const mutation = computeSplitsMutation(splitChanges.splits);
+          const mutation = computeSplitsMutation(splitChanges.splits, splitFiltersValidation);
 
           log.debug(SYNC_SPLITS_NEW, [mutation.added.length]);
           log.debug(SYNC_SPLITS_REMOVED, [mutation.removed.length]);

package/src/sync/submitters/telemetrySubmitter.ts

@@ -3,12 +3,13 @@ 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 } from '../../types';
+import { ConsentStatus, ISettings, SDKMode, SplitIO } 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,
@@ -38,6 +39,18 @@ 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
@@ -59,6 +72,8 @@ 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: {
@@ -86,7 +101,9 @@ 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
+        uC: settings.userConsent ? USER_CONSENT_MAP[settings.userConsent] : 0,
+        fsT: flagSetsTotal,
+        fsI: flagSetsIgnored
       });
     }
   };

package/src/sync/submitters/types.ts

@@ -124,7 +124,11 @@ export type TREATMENTS = 'ts';
 export type TREATMENT_WITH_CONFIG = 'tc';
 export type TREATMENTS_WITH_CONFIG = 'tcs';
 export type TRACK = 'tr';
-export type Method = TREATMENT | TREATMENTS | TREATMENT_WITH_CONFIG | TREATMENTS_WITH_CONFIG | TRACK;
+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 MethodLatencies = Partial<Record<Method, Array<number>>>;
 
@@ -234,6 +238,8 @@ 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 {