@splitsoftware/splitio-commons 2.7.2-rc.0 → 2.7.9-rc.1

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

@@ -4,7 +4,6 @@ import { IReadinessManager } from '../../../readiness/types';
 import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
 import { LOG_PREFIX_INSTANTIATION, LOG_PREFIX_SYNC_SEGMENTS } from '../../../logger/constants';
-import { timeout } from '../../../utils/promise/timeout';
 
 type ISegmentChangesUpdater = (fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number) => Promise<boolean>
 
@@ -24,18 +23,11 @@ export function segmentChangesUpdaterFactory(
   segmentChangesFetcher: ISegmentChangesFetcher,
   segments: ISegmentsCacheBase,
   readiness?: IReadinessManager,
-  requestTimeoutBeforeReady?: number,
-  retriesOnFailureBeforeReady?: number,
 ): ISegmentChangesUpdater {
 
   let readyOnAlreadyExistentState = true;
 
-  function _promiseDecorator<T>(promise: Promise<T>) {
-    if (readyOnAlreadyExistentState && requestTimeoutBeforeReady) promise = timeout(requestTimeoutBeforeReady, promise);
-    return promise;
-  }
-
-  function updateSegment(segmentName: string, noCache?: boolean, till?: number, fetchOnlyNew?: boolean, retries?: number): Promise<boolean> {
+  function updateSegment(segmentName: string, noCache?: boolean, till?: number, fetchOnlyNew?: boolean): Promise<boolean> {
     log.debug(`${LOG_PREFIX_SYNC_SEGMENTS}Processing segment ${segmentName}`);
     let sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
 
@@ -43,19 +35,13 @@ export function segmentChangesUpdaterFactory(
       // if fetchOnlyNew flag, avoid processing already fetched segments
       return fetchOnlyNew && since !== undefined ?
         false :
-        segmentChangesFetcher(since || -1, segmentName, noCache, till, _promiseDecorator).then((changes) => {
+        segmentChangesFetcher(since || -1, segmentName, noCache, till).then((changes) => {
           return Promise.all(changes.map(x => {
             log.debug(`${LOG_PREFIX_SYNC_SEGMENTS}Processing ${segmentName} with till = ${x.till}. Added: ${x.added.length}. Removed: ${x.removed.length}`);
             return segments.update(segmentName, x.added, x.removed, x.till);
           })).then((updates) => {
             return updates.some(update => update);
           });
-        }).catch(error => {
-          if (retries) {
-            log.warn(`${LOG_PREFIX_SYNC_SEGMENTS}Retrying fetch of segment ${segmentName} (attempt #${retries}). Reason: ${error}`);
-            return updateSegment(segmentName, noCache, till, fetchOnlyNew, retries - 1);
-          }
-          throw error;
         });
     });
   }
@@ -77,7 +63,8 @@ export function segmentChangesUpdaterFactory(
     let segmentsPromise = Promise.resolve(segmentName ? [segmentName] : segments.getRegisteredSegments());
 
     return segmentsPromise.then(segmentNames => {
-      const updaters = segmentNames.map(segmentName => updateSegment(segmentName, noCache, till, fetchOnlyNew, readyOnAlreadyExistentState ? retriesOnFailureBeforeReady : 0));
+      // Async fetchers
+      const updaters = segmentNames.map(segmentName => updateSegment(segmentName, noCache, till, fetchOnlyNew));
 
       return Promise.all(updaters).then(shouldUpdateFlags => {
         // if at least one segment fetch succeeded, mark segments ready

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

@@ -120,8 +120,8 @@ export function splitChangesUpdaterFactory(
   storage: Pick<IStorageBase, 'splits' | 'rbSegments' | 'segments' | 'save'>,
   splitFiltersValidation: ISplitFiltersValidation,
   splitsEventEmitter?: ISplitsEventEmitter,
-  requestTimeoutBeforeReady = 0,
-  retriesOnFailureBeforeReady = 0,
+  requestTimeoutBeforeReady: number = 0,
+  retriesOnFailureBeforeReady: number = 0,
   isClientSide?: boolean
 ): SplitChangesUpdater {
   const { splits, rbSegments, segments } = storage;
@@ -201,13 +201,14 @@ export function splitChangesUpdaterFactory(
           });
         })
         .catch(error => {
+          log.warn(SYNC_SPLITS_FETCH_FAILS, [error]);
+
           if (startingUp && retriesOnFailureBeforeReady > retry) {
             retry += 1;
-            log.warn(SYNC_SPLITS_FETCH_RETRY, [retry, error]);
+            log.info(SYNC_SPLITS_FETCH_RETRY, [retry, error]);
             return _splitChangesUpdater(sinces, retry);
           } else {
             startingUp = false;
-            log.warn(SYNC_SPLITS_FETCH_FAILS, [error]);
           }
           return false;
         });

package/src/sync/streaming/SSEHandler/index.ts

@@ -25,7 +25,7 @@ export function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventEmitter,
       const code = error.parsedData.code;
       telemetryTracker.streamingEvent(ABLY_ERROR, code);
 
-      // 401 errors due to invalid or expired token (e.g., if refresh token coudn't be executed)
+      // 401 errors due to invalid or expired token (e.g., if refresh token couldn't be executed)
       if (40140 <= code && code <= 40149) return true;
       // Others 4XX errors (e.g., bad request from the SDK)
       if (40000 <= code && code <= 49999) return false;

package/src/sync/submitters/telemetrySubmitter.ts

@@ -119,7 +119,7 @@ export function telemetrySubmitterFactory(params: ISdkFactoryContextSync) {
   if (!telemetry || !now) return; // No submitter created if telemetry cache is not defined
 
   const { settings, settings: { log, scheduler: { telemetryRefreshRate } }, splitApi, readiness, sdkReadinessManager } = params;
-  const startTime = timer(now);
+  const stopTimer = timer(now);
 
   const submitter = firstPushWindowDecorator(
     submitterFactory(
@@ -131,12 +131,12 @@ export function telemetrySubmitterFactory(params: ISdkFactoryContextSync) {
   );
 
   readiness.gate.once(SDK_READY_FROM_CACHE, () => {
-    telemetry.recordTimeUntilReadyFromCache(startTime());
+    telemetry.recordTimeUntilReadyFromCache(stopTimer());
   });
 
   sdkReadinessManager.incInternalReadyCbCount();
   readiness.gate.once(SDK_READY, () => {
-    telemetry.recordTimeUntilReady(startTime());
+    telemetry.recordTimeUntilReady(stopTimer());
 
     // Post config data when the SDK is ready and if the telemetry submitter was started
     if (submitter.isRunning()) {

package/src/trackers/telemetryTracker.ts

@@ -11,11 +11,11 @@ export function telemetryTrackerFactory(
 ): ITelemetryTracker {
 
   if (telemetryCache && now) {
-    const startTime = timer(now);
+    const sessionTimer = timer(now);
 
     return {
       trackEval(method) {
-        const evalTime = timer(now);
+        const evalTimer = timer(now);
 
         return (label) => {
           switch (label) {
@@ -25,20 +25,20 @@ export function telemetryTrackerFactory(
             case SDK_NOT_READY: // @ts-ignore ITelemetryCacheAsync doesn't implement the method
               if (telemetryCache.recordNonReadyUsage) telemetryCache.recordNonReadyUsage();
           }
-          telemetryCache.recordLatency(method, evalTime());
+          telemetryCache.recordLatency(method, evalTimer());
         };
       },
       trackHttp(operation) {
-        const httpTime = timer(now);
+        const httpTimer = timer(now);
 
         return (error) => {
-          (telemetryCache as ITelemetryCacheSync).recordHttpLatency(operation, httpTime());
+          (telemetryCache as ITelemetryCacheSync).recordHttpLatency(operation, httpTimer());
           if (error && error.statusCode) (telemetryCache as ITelemetryCacheSync).recordHttpError(operation, error.statusCode);
           else (telemetryCache as ITelemetryCacheSync).recordSuccessfulSync(operation, Date.now());
         };
       },
       sessionLength() { // @ts-ignore ITelemetryCacheAsync doesn't implement the method
-        if (telemetryCache.recordSessionLength) telemetryCache.recordSessionLength(startTime());
+        if (telemetryCache.recordSessionLength) telemetryCache.recordSessionLength(sessionTimer());
       },
       streamingEvent(e, d) {
         if (e === AUTH_REJECTION) {

package/src/utils/inputValidation/index.ts

@@ -7,7 +7,7 @@ export { validateKey } from './key';
 export { validateSplit } from './split';
 export { validateSplits } from './splits';
 export { validateTrafficType } from './trafficType';
-export { validateIfNotDestroyed, validateIfOperational } from './isOperational';
+export { validateIfNotDestroyed, validateIfReadyFromCache, validateIfOperational } from './isOperational';
 export { validateSplitExistence } from './splitExistence';
 export { validateTrafficTypeExistence } from './trafficTypeExistence';
 export { validateEvaluationOptions } from './eventProperties';

package/src/utils/inputValidation/isOperational.ts

@@ -1,4 +1,4 @@
-import { ERROR_CLIENT_DESTROYED, CLIENT_NOT_READY } from '../../logger/constants';
+import { ERROR_CLIENT_DESTROYED, CLIENT_NOT_READY_FROM_CACHE } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 import { IReadinessManager } from '../../readiness/types';
 
@@ -9,9 +9,14 @@ export function validateIfNotDestroyed(log: ILogger, readinessManager: IReadines
   return false;
 }
 
-export function validateIfOperational(log: ILogger, readinessManager: IReadinessManager, method: string, featureFlagNameOrNames?: string | string[] | false) {
-  if (readinessManager.isReady() || readinessManager.isReadyFromCache()) return true;
+export function validateIfReadyFromCache(log: ILogger, readinessManager: IReadinessManager, method: string, featureFlagNameOrNames?: string | string[] | false) {
+  if (readinessManager.isReadyFromCache()) return true;
 
-  log.warn(CLIENT_NOT_READY, [method, featureFlagNameOrNames ? ` for feature flag ${featureFlagNameOrNames.toString()}` : '']);
+  log.warn(CLIENT_NOT_READY_FROM_CACHE, [method, featureFlagNameOrNames ? ` for feature flag ${featureFlagNameOrNames.toString()}` : '']);
   return false;
 }
+
+// Operational means that the SDK is ready to evaluate (not destroyed and ready from cache)
+export function validateIfOperational(log: ILogger, readinessManager: IReadinessManager, method: string, featureFlagNameOrNames?: string | string[] | false) {
+  return validateIfNotDestroyed(log, readinessManager, method) && validateIfReadyFromCache(log, readinessManager, method, featureFlagNameOrNames);
+}

package/src/utils/inputValidation/splitExistence.ts

@@ -1,15 +1,15 @@
-import { SPLIT_NOT_FOUND } from '../labels';
+import { FALLBACK_SPLIT_NOT_FOUND, SPLIT_NOT_FOUND } from '../labels';
 import { IReadinessManager } from '../../readiness/types';
 import { ILogger } from '../../logger/types';
 import { WARN_NOT_EXISTENT_SPLIT } from '../../logger/constants';
 
 /**
  * This is defined here and in this format mostly because of the logger and the fact that it's considered a validation at product level.
- * But it's not going to run on the input validation layer. In any case, the most compeling reason to use it as we do is to avoid going to Redis and get a split twice.
+ * But it's not going to run on the input validation layer. In any case, the most compelling reason to use it as we do is to avoid going to Redis and get a split twice.
  */
 export function validateSplitExistence(log: ILogger, readinessManager: IReadinessManager, splitName: string, labelOrSplitObj: any, method: string): boolean {
-  if (readinessManager.isReady()) { // Only if it's ready we validate this, otherwise it may just be that the SDK is not ready yet.
-    if (labelOrSplitObj === SPLIT_NOT_FOUND || labelOrSplitObj == null) {
+  if (readinessManager.isReady()) { // Only if it's ready (synced with BE) we validate this, otherwise it may just be that the SDK is still syncing
+    if (labelOrSplitObj === SPLIT_NOT_FOUND || labelOrSplitObj === FALLBACK_SPLIT_NOT_FOUND || labelOrSplitObj == null) {
       log.warn(WARN_NOT_EXISTENT_SPLIT, [method, splitName]);
       return false;
     }

package/src/utils/labels/index.ts

@@ -1,3 +1,5 @@
+import { FALLBACK_PREFIX } from '../../evaluator/fallbackTreatmentsCalculator';
+
 export const SPLIT_KILLED = 'killed';
 export const NO_CONDITION_MATCH = 'default rule';
 export const SPLIT_NOT_FOUND = 'definition not found';
@@ -7,3 +9,4 @@ export const SPLIT_ARCHIVED = 'archived';
 export const NOT_IN_SPLIT = 'not in split';
 export const UNSUPPORTED_MATCHER_TYPE = 'targeting rule type unsupported by sdk';
 export const PREREQUISITES_NOT_MET = 'prerequisites not met';
+export const FALLBACK_SPLIT_NOT_FOUND = FALLBACK_PREFIX + SPLIT_NOT_FOUND;

package/types/splitio.d.ts

@@ -525,19 +525,19 @@ declare namespace SplitIO {
    */
   type EventConsts = {
     /**
-     * The ready event.
+     * The ready event emitted once the SDK is ready to evaluate feature flags with cache synchronized with the backend.
      */
     SDK_READY: 'init::ready';
     /**
-     * The ready event when fired with cached data.
+     * The ready event emitted once the SDK is ready to evaluate feature flags with cache that could be stale. Use SDK_READY if you want to be sure the cache is in sync with the backend.
      */
     SDK_READY_FROM_CACHE: 'init::cache-ready';
     /**
-     * The timeout event.
+     * The timeout event emitted after `startup.readyTimeout` seconds if the SDK_READY event was not emitted.
      */
     SDK_READY_TIMED_OUT: 'init::timeout';
     /**
-     * The update event.
+     * The update event emitted when the SDK cache is updated with new data from the backend.
      */
     SDK_UPDATE: 'state::update';
   };
@@ -618,6 +618,10 @@ declare namespace SplitIO {
      * User consent status if using in client-side. Undefined if using in server-side (Node.js).
      */
     readonly userConsent?: ConsentStatus;
+    /**
+     * Fallback treatments to be used when the SDK is not ready or the flag is not found.
+     */
+    readonly fallbackTreatments?: FallbackTreatmentConfiguration;
   }
   /**
    * Log levels.
@@ -700,7 +704,7 @@ declare namespace SplitIO {
      */
     Event: EventConsts;
     /**
-     * Returns a promise that resolves once the SDK has finished loading (`SDK_READY` event emitted) or rejected if the SDK has timedout (`SDK_READY_TIMED_OUT` event emitted).
+     * Returns a promise that resolves when the SDK has finished initial synchronization with the backend (`SDK_READY` event emitted), or rejected if the SDK has timedout (`SDK_READY_TIMED_OUT` event emitted).
      * As it's meant to provide similar flexibility to the event approach, given that the SDK might be eventually ready after a timeout event, the `ready` method will return a resolved promise once the SDK is ready.
      *
      * Caveats: the method was designed to avoid an unhandled Promise rejection if the rejection case is not handled, so that `onRejected` handler is optional when using promises.
@@ -715,8 +719,26 @@ declare namespace SplitIO {
      * ```
      *
      * @returns A promise that resolves once the SDK is ready or rejects if the SDK has timedout.
+     * @deprecated Use `whenReady` instead.
      */
     ready(): Promise<void>;
+    /**
+     * Returns a promise that resolves when the SDK has finished initial synchronization with the backend (`SDK_READY` event emitted), or rejected if the SDK has timedout (`SDK_READY_TIMED_OUT` event emitted).
+     * As it's meant to provide similar flexibility than event listeners, given that the SDK might be ready after a timeout event, the `whenReady` method will return a resolved promise once the SDK is ready.
+     * You must handle the promise rejection to avoid an unhandled promise rejection error, or set the `startup.readyTimeout` configuration option to 0 to avoid the timeout and thus the rejection.
+     *
+     * @returns A promise that resolves once the SDK_READY event is emitted or rejects if the SDK has timedout.
+     */
+    whenReady(): Promise<void>;
+    /**
+     * Returns a promise that resolves when the SDK is ready for evaluations using cached data, which might not yet be synchronized with the backend (`SDK_READY_FROM_CACHE` event emitted), or rejected if the SDK has timedout (`SDK_READY_TIMED_OUT` event emitted).
+     * As it's meant to provide similar flexibility than event listeners, given that the SDK might be ready from cache after a timeout event, the `whenReadyFromCache` method will return a resolved promise once the SDK is ready from cache.
+     * You must handle the promise rejection to avoid an unhandled promise rejection error, or set the `startup.readyTimeout` configuration option to 0 to avoid the timeout and thus the rejection.
+     *
+     * @returns A promise that resolves once the SDK_READY_FROM_CACHE event is emitted or rejects if the SDK has timedout. The promise resolves with a boolean value that
+     * indicates whether the SDK_READY_FROM_CACHE event was emitted together with the SDK_READY event (i.e., the SDK is ready and synchronized with the backend) or not.
+     */
+    whenReadyFromCache(): Promise<boolean>;
   }
   /**
    * Common definitions between clients for different environments interface.
@@ -1225,6 +1247,15 @@ declare namespace SplitIO {
    * User consent status.
    */
   type ConsentStatus = 'GRANTED' | 'DECLINED' | 'UNKNOWN';
+  /**
+   * Fallback treatments to be used when the SDK is not ready or the flag is not found.
+   */
+  type FallbackTreatmentConfiguration = {
+    global?: Treatment | TreatmentWithConfig,
+    byFlag?: {
+      [featureFlagName: string]: Treatment | TreatmentWithConfig
+    }
+  }
   /**
    * Logger. Its interface details are not part of the public API. It shouldn't be used directly.
    */
@@ -1650,7 +1681,7 @@ declare namespace SplitIO {
      * Wait for the SDK client to be ready before calling this method.
      *
      * ```js
-     * await factory.client().ready();
+     * await factory.client().whenReady();
      * const rolloutPlan = factory.getRolloutPlan();
      * ```
      *