Merge pull request #343 from splitio/development

Release v1.17.0

Author: EmilianoSanchez

CHANGES.txt

@@ -1,3 +1,8 @@
+1.17.0 (September 6, 2024)
+ - Added `sync.requestOptions.getHeaderOverrides` configuration option to enhance SDK HTTP request Headers for Authorization Frameworks.
+ - Added `isTimedout` and `lastUpdate` properties to IStatusInterface to keep track of the timestamp of the last SDK event, used on React and Redux SDKs.
+ - Updated some transitive dependencies for vulnerability fixes.
+
 1.16.0 (June 13, 2024)
  - Added the `getOptions` method to the `IPlatform` interface to allow the SDK to pass request options to the `fetch` function and `EventSource` constructor when fetching data from the Split servers. The method is optional and, if provided, it is called twice: first for the `fetch` options and then for the `EventSource` options. Useful for advanced use cases like configuring a proxy or validating HTTPS certificates in NodeJS.
  - Updated the Redis storage to lazily import the `ioredis` dependency when the storage is created. This prevents errors when the SDK is imported or bundled in a .mjs file, as `ioredis` is a CommonJS module.

package-lock.json

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

package.json

@@ -120,6 +120,7 @@ export const ENGINE_MATCHER_ERROR = 329;
 // Log prefixes (a.k.a. tags or categories)
 export const LOG_PREFIX_SETTINGS = 'settings';
 export const LOG_PREFIX_INSTANTIATION = 'Factory instantiation';
+export const LOG_PREFIX_CLIENT_INSTANTIATION = 'Client instantiation';
 export const LOG_PREFIX_ENGINE = 'engine';
 export const LOG_PREFIX_ENGINE_COMBINER = LOG_PREFIX_ENGINE + ':combiner: ';
 export const LOG_PREFIX_ENGINE_MATCHER = LOG_PREFIX_ENGINE + ':matcher: ';

src/logger/constants.ts

@@ -4,14 +4,16 @@ import { IReadinessManager } from '../types';
 import { SDK_READY, SDK_UPDATE, SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_READY_FROM_CACHE, SDK_SPLITS_CACHE_LOADED, SDK_READY_TIMED_OUT } from '../constants';
 
 const timeoutMs = 100;
-const statusFlagsCount = 5;
+const statusFlagsCount = 7;
 
 function assertInitialStatus(readinessManager: IReadinessManager) {
   expect(readinessManager.isReady()).toBe(false);
   expect(readinessManager.isReadyFromCache()).toBe(false);
+  expect(readinessManager.isTimedout()).toBe(false);
   expect(readinessManager.hasTimedout()).toBe(false);
   expect(readinessManager.isDestroyed()).toBe(false);
   expect(readinessManager.isOperational()).toBe(false);
+  expect(readinessManager.lastUpdate()).toBe(0);
 }
 
 test('READINESS MANAGER / Share splits but segments (without timeout enabled)', (done) => {
@@ -153,6 +155,7 @@ describe('READINESS MANAGER / Timeout ready event', () => {
     timeoutCounter = 0;
 
     readinessManager.gate.on(SDK_READY_TIMED_OUT, () => {
+      expect(readinessManager.isTimedout()).toBe(true);
       expect(readinessManager.hasTimedout()).toBe(true);
       if (!readinessManager.isReady()) timeoutCounter++;
     });
@@ -166,6 +169,8 @@ describe('READINESS MANAGER / Timeout ready event', () => {
   test('should be fired once', (done) => {
     readinessManager.gate.on(SDK_READY, () => {
       expect(readinessManager.isReady()).toBe(true);
+      expect(readinessManager.isTimedout()).toBe(false);
+      expect(readinessManager.hasTimedout()).toBe(true);
       expect(timeoutCounter).toBe(1);
       done();
     });
@@ -221,14 +226,24 @@ test('READINESS MANAGER / Destroy after it was ready but before timedout', () =>
     counter++;
   });
 
+  let lastUpdate = readinessManager.lastUpdate();
+  expect(lastUpdate).toBe(0);
+
   readinessManager.splits.emit(SDK_SPLITS_ARRIVED);
   readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED); // ready state
 
+  expect(readinessManager.lastUpdate()).toBeGreaterThan(lastUpdate);
+  lastUpdate = readinessManager.lastUpdate();
+
   readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED); // fires an update
+  expect(readinessManager.lastUpdate()).toBeGreaterThan(lastUpdate);
+  lastUpdate = readinessManager.lastUpdate();
 
   expect(readinessManager.isDestroyed()).toBe(false);
   readinessManager.destroy(); // Destroy the gate, removing all the listeners and clearing the ready timeout.
   expect(readinessManager.isDestroyed()).toBe(true);
+  expect(readinessManager.lastUpdate()).toBeGreaterThan(lastUpdate);
+
   readinessManager.destroy(); // no-op
   readinessManager.destroy(); // no-op
 

src/readiness/__tests__/readinessManager.spec.ts

@@ -50,6 +50,10 @@ describe('SDK Readiness Manager - Event emitter', () => {
     });
 
     expect(typeof sdkStatus.ready).toBe('function'); // The sdkStatus exposes a .ready() function.
+    expect(typeof sdkStatus.__getStatus).toBe('function'); // The sdkStatus exposes a .__getStatus() function.
+    expect(sdkStatus.__getStatus()).toEqual({
+      isReady: false, isReadyFromCache: false, isTimedout: false, hasTimedout: false, isDestroyed: false, isOperational: false, lastUpdate: 0
+    });
 
     expect(typeof sdkStatus.Event).toBe('object'); // It also exposes the Event map,
     expect(sdkStatus.Event.SDK_READY).toBe(SDK_READY); // which contains the constants for the events, for backwards compatibility.

src/readiness/__tests__/sdkReadinessManager.spec.ts

@@ -39,6 +39,13 @@ export function readinessManagerFactory(
   const segments: ISegmentsEventEmitter = segmentsEventEmitterFactory(EventEmitter);
   const gate: IReadinessEventEmitter = new EventEmitter();
 
+  let lastUpdate = 0;
+  function syncLastUpdate() {
+    const dateNow = Date.now();
+    // ensure lastUpdate is always increasing per event, is case Date.now() is mocked or its value is the same
+    lastUpdate = dateNow > lastUpdate ? dateNow : lastUpdate + 1;
+  }
+
   // emit SDK_READY_FROM_CACHE
   let isReadyFromCache = false;
   if (splits.splitsCacheLoaded) isReadyFromCache = true; // ready from cache, but doesn't emit SDK_READY_FROM_CACHE
@@ -50,6 +57,7 @@ export function readinessManagerFactory(
   function timeout() {
     if (hasTimedout) return;
     hasTimedout = true;
+    syncLastUpdate();
     gate.emit(SDK_READY_TIMED_OUT, 'Split SDK emitted SDK_READY_TIMED_OUT event.');
   }
 
@@ -70,6 +78,7 @@ export function readinessManagerFactory(
     // Don't emit SDK_READY_FROM_CACHE if SDK_READY has been emitted
     if (!isReady) {
       try {
+        syncLastUpdate();
         gate.emit(SDK_READY_FROM_CACHE);
       } catch (e) {
         // throws user callback exceptions in next tick
@@ -81,6 +90,7 @@ export function readinessManagerFactory(
   function checkIsReadyOrUpdate(diff: any) {
     if (isReady) {
       try {
+        syncLastUpdate();
         gate.emit(SDK_UPDATE, diff);
       } catch (e) {
         // throws user callback exceptions in next tick
@@ -91,6 +101,7 @@ export function readinessManagerFactory(
         clearTimeout(readyTimeoutId);
         isReady = true;
         try {
+          syncLastUpdate();
           gate.emit(SDK_READY);
         } catch (e) {
           // throws user callback exceptions in next tick
@@ -121,6 +132,7 @@ export function readinessManagerFactory(
 
     destroy() {
       isDestroyed = true;
+      syncLastUpdate();
 
       segments.removeAllListeners();
       gate.removeAllListeners();
@@ -131,10 +143,12 @@ export function readinessManagerFactory(
     },
 
     isReady() { return isReady; },
-    hasTimedout() { return hasTimedout; },
     isReadyFromCache() { return isReadyFromCache; },
+    isTimedout() { return hasTimedout && !isReady; },
+    hasTimedout() { return hasTimedout; },
     isDestroyed() { return isDestroyed; },
-    isOperational() { return (isReady || isReadyFromCache) && !isDestroyed; }
+    isOperational() { return (isReady || isReadyFromCache) && !isDestroyed; },
+    lastUpdate() { return lastUpdate; }
   };
 
 }

src/readiness/readinessManager.ts

@@ -121,14 +121,15 @@ export function sdkReadinessManagerFactory(
           return readyPromise;
         },
 
-        // Expose status for internal purposes only. Not considered part of the public API, and might be updated eventually.
         __getStatus() {
           return {
             isReady: readinessManager.isReady(),
             isReadyFromCache: readinessManager.isReadyFromCache(),
-            isOperational: readinessManager.isOperational(),
+            isTimedout: readinessManager.isTimedout(),
             hasTimedout: readinessManager.hasTimedout(),
             isDestroyed: readinessManager.isDestroyed(),
+            isOperational: readinessManager.isOperational(),
+            lastUpdate: readinessManager.lastUpdate(),
           };
         },
       }

src/readiness/sdkReadinessManager.ts

@@ -50,9 +50,11 @@ export interface IReadinessManager {
   /** Readiness status */
   isReady(): boolean,
   isReadyFromCache(): boolean,
+  isTimedout(): boolean,
   hasTimedout(): boolean,
   isDestroyed(): boolean,
   isOperational(): boolean,
+  lastUpdate(): number,
 
   timeout(): void,
   setDestroyed(): void,

src/readiness/types.ts

@@ -5,7 +5,7 @@ import { getMatching, keyParser } from '../utils/key';
 import { sdkClientFactory } from './sdkClient';
 import { ISyncManagerCS } from '../sync/types';
 import { objectAssign } from '../utils/lang/objectAssign';
-import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING } from '../logger/constants';
+import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING, LOG_PREFIX_CLIENT_INSTANTIATION } from '../logger/constants';
 import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 
@@ -14,8 +14,6 @@ function buildInstanceId(key: SplitIO.SplitKey) {
   return `${key.matchingKey ? key.matchingKey : key}-${key.bucketingKey ? key.bucketingKey : key}-`;
 }
 
-const method = 'Client instantiation';
-
 /**
  * Factory of client method for the client-side API variant where TT is ignored.
  * Therefore, clients don't have a bound TT for the track method.
@@ -43,7 +41,7 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
     }
 
     // Validate the key value. The trafficType (2nd argument) is ignored
-    const validKey = validateKey(log, key, method);
+    const validKey = validateKey(log, key, LOG_PREFIX_CLIENT_INSTANTIATION);
     if (validKey === false) {
       throw new Error('Shared Client needs a valid key.');
     }