Merge pull request #286 from splitio/development

Release v1.12.1

Author: EmilianoSanchez

CHANGES.txt

@@ -1,3 +1,7 @@
+1.12.1 (December 12, 2023)
+ - Updated PluggableStorage, for producer mode, and LocalStorage, for standalone mode, to clear the storage before initiating the synchronization process if it was previously synchronized with a different SDK key (i.e., a different environment) or different Split Filter criteria.
+ - Bugfixing - Fixed an issue when tracking telemetry latencies for the new `getTreatmentsByFlagSet(s)` methods in Redis and Pluggable storages, which was causing the SDK to not track those stats.
+
 1.12.0 (December 4, 2023)
  - Added support for Flag Sets in "consumer" and "partial consumer" modes for Pluggable and Redis storages.
  - Updated evaluation flow to log a warning when using flag sets that don't contain cached feature flags.

package-lock.json

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

package.json

@@ -9,7 +9,7 @@ import { IEvaluationResult } from '../evaluator/types';
 import { SplitIO, ImpressionDTO } from '../types';
 import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
-import { isStorageSync } from '../trackers/impressionObserver/utils';
+import { isConsumerMode } from '../utils/settingsValidation/mode';
 import { Method } from '../sync/submitters/types';
 
 const treatmentNotReady = { treatment: CONTROL, label: SDK_NOT_READY };
@@ -28,6 +28,7 @@ function treatmentsNotReady(featureFlagNames: string[]) {
 export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | SplitIO.IAsyncClient {
   const { sdkReadinessManager: { readinessManager }, storage, settings, impressionsTracker, eventTracker, telemetryTracker } = params;
   const { log, mode } = settings;
+  const isAsync = isConsumerMode(mode);
 
   function getTreatment(key: SplitIO.SplitKey, featureFlagName: string, attributes: SplitIO.Attributes | undefined, withConfig = false, methodName = GET_TREATMENT) {
     const stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENT_WITH_CONFIG : TREATMENT);
@@ -43,9 +44,9 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
 
     const evaluation = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
       evaluateFeature(log, key, featureFlagName, attributes, storage) :
-      isStorageSync(settings) ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
-        treatmentNotReady :
-        Promise.resolve(treatmentNotReady); // Promisify if async
+      isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
+        Promise.resolve(treatmentNotReady) :
+        treatmentNotReady;
 
     return thenable(evaluation) ? evaluation.then((res) => wrapUp(res)) : wrapUp(evaluation);
   }
@@ -71,9 +72,9 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
 
     const evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
       evaluateFeatures(log, key, featureFlagNames, attributes, storage) :
-      isStorageSync(settings) ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
-        treatmentsNotReady(featureFlagNames) :
-        Promise.resolve(treatmentsNotReady(featureFlagNames)); // Promisify if async
+      isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
+        Promise.resolve(treatmentsNotReady(featureFlagNames)) :
+        treatmentsNotReady(featureFlagNames);
 
     return thenable(evaluations) ? evaluations.then((res) => wrapUp(res)) : wrapUp(evaluations);
   }
@@ -100,7 +101,9 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
 
     const evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
       evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, methodName) :
-      isStorageSync(settings) ? {} : Promise.resolve({}); // Promisify if async
+      isAsync ?
+        Promise.resolve({}) :
+        {};
 
     return thenable(evaluations) ? evaluations.then((res) => wrapUp(res)) : wrapUp(evaluations);
   }

src/sdkClient/client.ts

@@ -16,7 +16,7 @@ import { CONTROL, CONTROL_WITH_CONFIG, GET_TREATMENT, GET_TREATMENTS, GET_TREATM
 import { IReadinessManager } from '../readiness/types';
 import { MaybeThenable } from '../dtos/types';
 import { ISettings, SplitIO } from '../types';
-import { isStorageSync } from '../trackers/impressionObserver/utils';
+import { isConsumerMode } from '../utils/settingsValidation/mode';
 import { validateFlagSets } from '../utils/settingsValidation/splitFilters';
 
 /**
@@ -25,8 +25,8 @@ import { validateFlagSets } from '../utils/settingsValidation/splitFilters';
  */
 export function clientInputValidationDecorator<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(settings: ISettings, client: TClient, readinessManager: IReadinessManager): TClient {
 
-  const log = settings.log;
-  const isSync = isStorageSync(settings);
+  const { log, mode } = settings;
+  const isAsync = isConsumerMode(mode);
 
   /**
    * Avoid repeating this validations code
@@ -59,7 +59,7 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
   }
 
   function wrapResult<T>(value: T): MaybeThenable<T> {
-    return isSync ? value : Promise.resolve(value);
+    return isAsync ? Promise.resolve(value) : value;
   }
 
   function getTreatment(maybeKey: SplitIO.SplitKey, maybeFeatureFlagName: string, maybeAttributes?: SplitIO.Attributes) {
@@ -159,7 +159,7 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     if (isNotDestroyed && key && tt && event && eventValue !== false && properties !== false) { // @ts-expect-error
       return client.track(key, tt, event, eventValue, properties, size);
     } else {
-      return isSync ? false : Promise.resolve(false);
+      return isAsync ? Promise.resolve(false) : false;
     }
   }
 

src/sdkClient/clientInputValidation.ts

@@ -6,7 +6,7 @@ import { ISplitsCacheAsync, ISplitsCacheSync } from '../storages/types';
 import { ISdkReadinessManager } from '../readiness/types';
 import { ISplit } from '../dtos/types';
 import { ISettings, SplitIO } from '../types';
-import { isStorageSync } from '../trackers/impressionObserver/utils';
+import { isConsumerMode } from '../utils/settingsValidation/mode';
 import { SPLIT_FN_LABEL, SPLITS_FN_LABEL, NAMES_FN_LABEL } from '../utils/constants';
 
 function collectTreatments(splitObject: ISplit) {
@@ -51,8 +51,8 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
   { readinessManager, sdkStatus }: ISdkReadinessManager,
 ): TSplitCache extends ISplitsCacheAsync ? SplitIO.IAsyncManager : SplitIO.IManager {
 
-  const log = settings.log;
-  const isSync = isStorageSync(settings);
+  const { log, mode } = settings;
+  const isAsync = isConsumerMode(mode);
 
   return objectAssign(
     // Proto-linkage of the readiness Event Emitter
@@ -64,7 +64,7 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
       split(featureFlagName: string) {
         const splitName = validateSplit(log, featureFlagName, SPLIT_FN_LABEL);
         if (!validateIfNotDestroyed(log, readinessManager, SPLIT_FN_LABEL) || !validateIfOperational(log, readinessManager, SPLIT_FN_LABEL) || !splitName) {
-          return isSync ? null : Promise.resolve(null);
+          return isAsync ? Promise.resolve(null) : null;
         }
 
         const split = splits.getSplit(splitName);
@@ -85,7 +85,7 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
        */
       splits() {
         if (!validateIfNotDestroyed(log, readinessManager, SPLITS_FN_LABEL) || !validateIfOperational(log, readinessManager, SPLITS_FN_LABEL)) {
-          return isSync ? [] : Promise.resolve([]);
+          return isAsync ? Promise.resolve([]) : [];
         }
         const currentSplits = splits.getAll();
 
@@ -98,7 +98,7 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
        */
       names() {
         if (!validateIfNotDestroyed(log, readinessManager, NAMES_FN_LABEL) || !validateIfOperational(log, readinessManager, NAMES_FN_LABEL)) {
-          return isSync ? [] : Promise.resolve([]);
+          return isAsync ? Promise.resolve([]) : [];
         }
         const splitNames = splits.getSplitNames();
 

src/sdkManager/index.ts

@@ -1,4 +1,6 @@
+import { ISettings } from '../types';
 import { startsWith } from '../utils/lang';
+import { hash } from '../utils/murmur3/murmur3';
 
 const everythingAtTheEnd = /[^.]+$/;
 
@@ -10,7 +12,7 @@ export function validatePrefix(prefix: unknown) {
 
 export class KeyBuilder {
 
-  protected readonly prefix: string;
+  readonly prefix: string;
 
   constructor(prefix: string = DEFAULT_PREFIX) {
     this.prefix = prefix;
@@ -73,4 +75,15 @@ export class KeyBuilder {
     }
   }
 
+  buildHashKey() {
+    return `${this.prefix}.hash`;
+  }
+}
+
+/**
+ * Generates a murmur32 hash based on the authorization key and the feature flags filter query.
+ * The hash is in hexadecimal format (8 characters max, 32 bits).
+ */
+export function getStorageHash(settings: ISettings) {
+  return hash(`${settings.core.authorizationKey}::${settings.sync.__splitFiltersValidation.queryString}`).toString(16);
 }

src/storages/KeyBuilder.ts

@@ -9,7 +9,7 @@ export class KeyBuilderCS extends KeyBuilder {
   constructor(prefix: string, matchingKey: string) {
     super(prefix);
     this.matchingKey = matchingKey;
-    this.regexSplitsCacheKey = new RegExp(`^${prefix}\\.(splits?|trafficType)\\.`);
+    this.regexSplitsCacheKey = new RegExp(`^${prefix}\\.(splits?|trafficType|flagSet)\\.`);
   }
 
   /**
@@ -45,8 +45,4 @@ export class KeyBuilderCS extends KeyBuilder {
   isSplitsCacheKey(key: string) {
     return this.regexSplitsCacheKey.test(key);
   }
-
-  buildSplitsFilterQueryKey() {
-    return `${this.prefix}.splits.filterQuery`;
-  }
 }

src/storages/KeyBuilderCS.ts

@@ -16,10 +16,10 @@ export const METHOD_NAMES: Record<Method, string> = {
 
 export class KeyBuilderSS extends KeyBuilder {
 
-  latencyPrefix: string;
-  exceptionPrefix: string;
-  initPrefix: string;
-  private versionablePrefix: string;
+  readonly latencyPrefix: string;
+  readonly exceptionPrefix: string;
+  readonly initPrefix: string;
+  private readonly versionablePrefix: string;
 
   constructor(prefix: string, metadata: IMetadata) {
     super(prefix);

src/storages/KeyBuilderSS.ts

@@ -1,4 +1,5 @@
-import { KeyBuilder } from '../KeyBuilder';
+import { ISettings } from '../../types';
+import { KeyBuilder, getStorageHash } from '../KeyBuilder';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 
 test('KEYS / splits keys', () => {
@@ -111,3 +112,20 @@ test('KEYS / latency and exception keys (telemetry)', () => {
   const expectedExceptionKey = `${prefix}.telemetry.exceptions::${metadata.s}/${metadata.n}/${metadata.i}/treatment`;
   expect(builder.buildExceptionKey(methodName)).toBe(expectedExceptionKey);
 });
+
+test('getStorageHash', () => {
+  expect(getStorageHash({
+    core: { authorizationKey: '<fake-token-rfc>' },
+    sync: { __splitFiltersValidation: { queryString: '&names=p1__split,p2__split' } }
+  } as ISettings)).toBe('6a596ded');
+
+  expect(getStorageHash({
+    core: { authorizationKey: '<fake-token-rfc>' },
+    sync: { __splitFiltersValidation: { queryString: '&names=p2__split,p3__split' } }
+  } as ISettings)).toBe('18ad36f3');
+
+  expect(getStorageHash({
+    core: { authorizationKey: '<fake-token-rfc>' },
+    sync: { __splitFiltersValidation: { queryString: null } }
+  } as ISettings)).toBe('9507ef4');
+});