@splitsoftware/splitio-commons 2.5.0-rc.0 → 11.5.0-rc.0

package/src/trackers/impressionObserver/buildKey.ts

@@ -1,5 +0,0 @@
-import SplitIO from '../../../types/splitio';
-
-export function buildKey(impression: SplitIO.ImpressionDTO) {
-  return `${impression.keyName}:${impression.feature}:${impression.treatment}:${impression.label}:${impression.changeNumber}`;
-}

package/src/trackers/impressionObserver/impressionObserverCS.ts

@@ -1,14 +0,0 @@
-import { ImpressionObserver } from './ImpressionObserver';
-import { hash } from '../../utils/murmur3/murmur3';
-import { buildKey } from './buildKey';
-import SplitIO from '../../../types/splitio';
-
-export function hashImpression32(impression: SplitIO.ImpressionDTO) {
-  return hash(buildKey(impression));
-}
-
-const LAST_SEEN_CACHE_SIZE = 500; // cache up to 500 impression hashes
-
-export function impressionObserverCSFactory() {
-  return new ImpressionObserver(LAST_SEEN_CACHE_SIZE, hashImpression32);
-}

package/src/trackers/impressionObserver/impressionObserverSS.ts

@@ -1,14 +0,0 @@
-import { ImpressionObserver } from './ImpressionObserver';
-import { hash128 } from '../../utils/murmur3/murmur3_128_x86';
-import { buildKey } from './buildKey';
-import SplitIO from '../../../types/splitio';
-
-export function hashImpression128(impression: SplitIO.ImpressionDTO) {
-  return hash128(buildKey(impression));
-}
-
-const LAST_SEEN_CACHE_SIZE = 500000; // cache up to 500k impression hashes
-
-export function impressionObserverSSFactory() {
-  return new ImpressionObserver(LAST_SEEN_CACHE_SIZE, hashImpression128);
-}

package/src/trackers/impressionObserver/types.ts

@@ -1,5 +0,0 @@
-import SplitIO from '../../../types/splitio';
-
-export interface IImpressionObserver {
-  testAndSet(impression: SplitIO.ImpressionDTO): number | undefined
-}

package/src/trackers/impressionsTracker.ts

@@ -1,87 +0,0 @@
-import { objectAssign } from '../utils/lang/objectAssign';
-import { thenable } from '../utils/promise/thenable';
-import { IImpressionsCacheBase, ITelemetryCacheSync, ITelemetryCacheAsync } from '../storages/types';
-import { IImpressionsHandler, IImpressionsTracker, ImpressionDecorated, IStrategy } from './types';
-import { ISettings } from '../types';
-import { IMPRESSIONS_TRACKER_SUCCESS, ERROR_IMPRESSIONS_TRACKER, ERROR_IMPRESSIONS_LISTENER } from '../logger/constants';
-import { CONSENT_DECLINED, DEDUPED, QUEUED } from '../utils/constants';
-import SplitIO from '../../types/splitio';
-
-/**
- * Impressions tracker stores impressions in cache and pass them to the listener and integrations manager if provided.
- */
-export function impressionsTrackerFactory(
-  settings: ISettings,
-  impressionsCache: IImpressionsCacheBase,
-  noneStrategy: IStrategy,
-  strategy: IStrategy,
-  whenInit: (cb: () => void) => void,
-  integrationsManager?: IImpressionsHandler,
-  telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync,
-): IImpressionsTracker {
-
-  const { log, impressionListener, runtime: { ip, hostname }, version } = settings;
-
-  return {
-    track(impressions: ImpressionDecorated[], attributes?: SplitIO.Attributes) {
-      if (settings.userConsent === CONSENT_DECLINED) return;
-
-      const impressionsToStore = impressions.filter(({ imp, disabled }) => {
-        return disabled ?
-          noneStrategy.process(imp) :
-          strategy.process(imp);
-      });
-
-      const impressionsLength = impressions.length;
-      const impressionsToStoreLength = impressionsToStore.length;
-
-      if (impressionsToStoreLength) {
-        const res = impressionsCache.track(impressionsToStore.map((item) => item.imp));
-
-        // If we're on an async storage, handle error and log it.
-        if (thenable(res)) {
-          res.then(() => {
-            log.info(IMPRESSIONS_TRACKER_SUCCESS, [impressionsLength]);
-          }).catch(err => {
-            log.error(ERROR_IMPRESSIONS_TRACKER, [impressionsLength, err]);
-          });
-        } else {
-          // Record when impressionsCache is sync only (standalone mode)
-          // @TODO we are not dropping impressions on full queue yet, so DROPPED stats are not recorded
-          if (telemetryCache) {
-            (telemetryCache as ITelemetryCacheSync).recordImpressionStats(QUEUED, impressionsToStoreLength);
-            (telemetryCache as ITelemetryCacheSync).recordImpressionStats(DEDUPED, impressionsLength - impressionsToStoreLength);
-          }
-        }
-      }
-
-      // @TODO next block might be handled by the integration manager. In that case, the metadata object doesn't need to be passed in the constructor
-      if (impressionListener || integrationsManager) {
-        for (let i = 0; i < impressionsLength; i++) {
-          const impressionData: SplitIO.ImpressionData = {
-            // copy of impression, to avoid unexpected behavior if modified by integrations or impressionListener
-            impression: objectAssign({}, impressions[i].imp),
-            attributes,
-            ip,
-            hostname,
-            sdkLanguageVersion: version
-          };
-
-          whenInit(() => {
-            // Wrap in a timeout because we don't want it to be blocking.
-            setTimeout(() => {
-              // integrationsManager.handleImpression does not throw errors
-              if (integrationsManager) integrationsManager.handleImpression(impressionData);
-
-              try { // @ts-ignore. An exception on the listeners should not break the SDK.
-                if (impressionListener) impressionListener.logImpression(impressionData);
-              } catch (err) {
-                log.error(ERROR_IMPRESSIONS_LISTENER, [err]);
-              }
-            });
-          });
-        }
-      }
-    }
-  };
-}

package/src/trackers/strategy/strategyDebug.ts

@@ -1,23 +0,0 @@
-import SplitIO from '../../../types/splitio';
-import { IImpressionObserver } from '../impressionObserver/types';
-import { IStrategy } from '../types';
-
-/**
- * Debug strategy for impressions tracker. Wraps impressions to store and adds previousTime if it corresponds
- *
- * @param impressionsObserver - impression observer. Previous time (pt property) is included in impression instances
- * @returns Debug strategy
- */
-export function strategyDebugFactory(
-  impressionsObserver: IImpressionObserver
-): IStrategy {
-
-  return {
-    process(impression: SplitIO.ImpressionDTO) {
-      if (impression.properties) return true;
-
-      impression.pt = impressionsObserver.testAndSet(impression);
-      return true;
-    }
-  };
-}

package/src/trackers/strategy/strategyNone.ts

@@ -1,28 +0,0 @@
-import { IImpressionCountsCacheBase } from '../../storages/types';
-import SplitIO from '../../../types/splitio';
-import { IStrategy, IUniqueKeysTracker } from '../types';
-
-/**
- * None strategy for impressions tracker.
- *
- * @param impressionCounts - cache to save impressions count. impressions will be deduped (OPTIMIZED mode)
- * @param uniqueKeysTracker - unique keys tracker in charge of tracking the unique keys per split.
- * @returns None strategy
- */
-export function strategyNoneFactory(
-  impressionCounts: IImpressionCountsCacheBase,
-  uniqueKeysTracker: IUniqueKeysTracker
-): IStrategy {
-
-  return {
-    process(impression: SplitIO.ImpressionDTO) {
-      const now = Date.now();
-      // Increments impression counter per featureName
-      impressionCounts.track(impression.feature, now, 1);
-      // Keep track by unique key
-      uniqueKeysTracker.track(impression.keyName, impression.feature);
-      // Do not store impressions
-      return false;
-    }
-  };
-}

package/src/trackers/strategy/strategyOptimized.ts

@@ -1,35 +0,0 @@
-import { IImpressionCountsCacheBase } from '../../storages/types';
-import SplitIO from '../../../types/splitio';
-import { truncateTimeFrame } from '../../utils/time';
-import { IImpressionObserver } from '../impressionObserver/types';
-import { IStrategy } from '../types';
-
-/**
- * Optimized strategy for impressions tracker. Wraps impressions to store and adds previousTime if it corresponds
- *
- * @param impressionsObserver - impression observer. previous time (pt property) is included in impression instances
- * @param impressionCounts - cache to save impressions count. impressions will be deduped (OPTIMIZED mode)
- * @returns Optimized strategy
- */
-export function strategyOptimizedFactory(
-  impressionsObserver: IImpressionObserver,
-  impressionCounts: IImpressionCountsCacheBase,
-): IStrategy {
-
-  return {
-    process(impression: SplitIO.ImpressionDTO) {
-      // DEBUG mode without previous time, for impressions with properties
-      if (impression.properties) return true;
-
-      impression.pt = impressionsObserver.testAndSet(impression);
-
-      const now = Date.now();
-
-      // Increments impression counter per featureName
-      if (impression.pt) impressionCounts.track(impression.feature, now, 1);
-
-      // Checks if the impression should be added in queue to be sent
-      return (!impression.pt || impression.pt < truncateTimeFrame(now)) ? true : false;
-    }
-  };
-}

package/src/trackers/telemetryTracker.ts

@@ -1,73 +0,0 @@
-import { ITelemetryCacheSync, ITelemetryCacheAsync } from '../storages/types';
-import { EXCEPTION, SDK_NOT_READY } from '../utils/labels';
-import { ITelemetryTracker } from './types';
-import { timer } from '../utils/timeTracker/timer';
-import { TOKEN_REFRESH, AUTH_REJECTION } from '../utils/constants';
-import { UpdatesFromSSEEnum } from '../sync/submitters/types';
-
-export function telemetryTrackerFactory(
-  telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync,
-  now?: () => number
-): ITelemetryTracker {
-
-  if (telemetryCache && now) {
-    const startTime = timer(now);
-
-    return {
-      trackEval(method) {
-        const evalTime = timer(now);
-
-        return (label) => {
-          switch (label) {
-            case EXCEPTION:
-              telemetryCache.recordException(method);
-              return; // Don't track latency on exceptions
-            case SDK_NOT_READY: // @ts-ignore ITelemetryCacheAsync doesn't implement the method
-              if (telemetryCache.recordNonReadyUsage) telemetryCache.recordNonReadyUsage();
-          }
-          telemetryCache.recordLatency(method, evalTime());
-        };
-      },
-      trackHttp(operation) {
-        const httpTime = timer(now);
-
-        return (error) => {
-          (telemetryCache as ITelemetryCacheSync).recordHttpLatency(operation, httpTime());
-          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());
-      },
-      streamingEvent(e, d) {
-        if (e === AUTH_REJECTION) {
-          (telemetryCache as ITelemetryCacheSync).recordAuthRejections();
-        } else {
-          (telemetryCache as ITelemetryCacheSync).recordStreamingEvents({
-            e, d, t: Date.now()
-          });
-          if (e === TOKEN_REFRESH) (telemetryCache as ITelemetryCacheSync).recordTokenRefreshes();
-        }
-      },
-      addTag(tag: string) {
-        // @ts-ignore
-        if (telemetryCache.addTag) telemetryCache.addTag(tag);
-      },
-      trackUpdatesFromSSE(type: UpdatesFromSSEEnum) {
-        (telemetryCache as ITelemetryCacheSync).recordUpdatesFromSSE(type);
-      }
-    };
-
-  } else { // If there is not `telemetryCache` or `now` time tracker, return a no-op telemetry tracker
-    const noopTrack = () => () => { };
-    return {
-      trackEval: noopTrack,
-      trackHttp: noopTrack,
-      sessionLength() { },
-      streamingEvent() { },
-      addTag() { },
-      trackUpdatesFromSSE() { },
-    };
-  }
-}

package/src/trackers/types.ts

@@ -1,86 +0,0 @@
-import SplitIO from '../../types/splitio';
-import { StreamingEventType, Method, OperationType, UpdatesFromSSEEnum } from '../sync/submitters/types';
-import { IEventsCacheBase } from '../storages/types';
-import { NetworkError } from '../services/types';
-
-/** Events tracker */
-
-export interface IEventsHandler {
-  handleEvent(eventData: SplitIO.EventData): any
-}
-
-export type IEventTracker = IEventsCacheBase
-
-/** Impressions tracker */
-
-export interface IImpressionsHandler {
-  handleImpression(impressionData: SplitIO.ImpressionData): any
-}
-
-export type ImpressionDecorated = {
-  /**
-   * Impression DTO
-   */
-  imp: SplitIO.ImpressionDTO,
-  /**
-   * Whether the impression should be tracked or not
-   */
-  disabled?: boolean
-};
-
-export interface IImpressionsTracker {
-  track(impressions: ImpressionDecorated[], attributes?: SplitIO.Attributes): void
-}
-
-/** Telemetry tracker */
-export type AUTH_REJECTION = 80;
-
-export interface ITelemetryTracker {
-  /**
-   * Creates a telemetry evaluator tracker, to record Latencies, Exceptions and NonReadyUsage of client operations (getTreatments and track method calls)
-   */
-  trackEval(method: Method): (label?: string) => void
-  /**
-   * Creates a telemetry runtime tracker, to record Latencies and Exceptions of HTTP requests
-   */
-  trackHttp(method: OperationType): (error?: NetworkError) => void
-  /**
-   * Records session length
-   */
-  sessionLength(): void
-  /**
-   * Records streaming event
-   */
-  streamingEvent(e: StreamingEventType | AUTH_REJECTION, d?: number): void
-  /**
-   * Records tag
-   */
-  addTag(tag: string): void
-  /**
-   * Records updates from sse
-   */
-  trackUpdatesFromSSE(type: UpdatesFromSSEEnum): void;
-}
-
-export interface IFilterAdapter {
-  add(key: string, featureName: string): boolean;
-  contains(key: string, featureName: string): boolean;
-  clear(): void;
-  refreshRate?: number;
-}
-
-export interface IImpressionSenderAdapter {
-  recordUniqueKeys(data: Object): void;
-  recordImpressionCounts(data: Object): void
-}
-
-/** Unique keys tracker */
-export interface IUniqueKeysTracker {
-  start(): void;
-  stop(): void;
-  track(key: string, featureName: string): void;
-}
-
-export interface IStrategy {
-  process(impression:  SplitIO.ImpressionDTO): boolean
-}

package/src/trackers/uniqueKeysTracker.ts

@@ -1,50 +0,0 @@
-import { LOG_PREFIX_UNIQUE_KEYS_TRACKER } from '../logger/constants';
-import { ILogger } from '../logger/types';
-import { IUniqueKeysCacheBase } from '../storages/types';
-import { IFilterAdapter, IUniqueKeysTracker } from './types';
-
-const noopFilterAdapter = {
-  add() { return true; },
-  contains() { return true; },
-  clear() { }
-};
-
-/**
- * Tracks uniques keys
- * Unique Keys Tracker will be in charge of checking if the MTK was already sent to the BE in the last period
- * or schedule to be sent; if not it will be added in an internal cache and sent in the next post.
- *
- * @param log - Logger instance
- * @param uniqueKeysCache - cache to save unique keys
- * @param filterAdapter - filter adapter
- */
-export function uniqueKeysTrackerFactory(
-  log: ILogger,
-  uniqueKeysCache: IUniqueKeysCacheBase,
-  filterAdapter: IFilterAdapter = noopFilterAdapter,
-): IUniqueKeysTracker {
-  let intervalId: any;
-
-  return {
-
-    track(key: string, featureName: string): void {
-      if (!filterAdapter.add(key, featureName)) {
-        log.debug(`${LOG_PREFIX_UNIQUE_KEYS_TRACKER}The feature ${featureName} and key ${key} exist in the filter`);
-        return;
-      }
-      uniqueKeysCache.track(key, featureName);
-    },
-
-    start(): void {
-      if (filterAdapter.refreshRate) {
-        intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
-      }
-    },
-
-    stop(): void {
-      clearInterval(intervalId);
-    }
-
-  };
-
-}

package/src/types.ts

@@ -1,44 +0,0 @@
-import SplitIO from '../types/splitio';
-import { ISplitFiltersValidation } from './dtos/types';
-import { ILogger } from './logger/types';
-
-/**
- * SplitIO.ISettings interface extended with private properties for internal use
- */
-export interface ISettings extends SplitIO.ISettings {
-  readonly sync: SplitIO.ISettings['sync'] & {
-    __splitFiltersValidation: ISplitFiltersValidation;
-  };
-  readonly log: ILogger;
-}
-
-/**
- * SplitIO.IStatusInterface interface extended with private properties for internal use
- */
-export interface IStatusInterface extends SplitIO.IStatusInterface {
-  // Expose status for internal purposes only. Not considered part of the public API, and might be updated eventually.
-  __getStatus(): {
-    isReady: boolean;
-    isReadyFromCache: boolean;
-    isTimedout: boolean;
-    hasTimedout: boolean;
-    isDestroyed: boolean;
-    isOperational: boolean;
-    lastUpdate: number;
-  };
-}
-/**
- * SplitIO.IBasicClient interface extended with private properties for internal use
- */
-export interface IBasicClient extends SplitIO.IBasicClient {
-  /**
-   * Flush data
-   *
-   * @returns A promise that is resolved when the flush is completed.
-   */
-  flush(): Promise<void>;
-  // Whether the client implements the client-side API, i.e, with bound key, (true), or the server-side API (false/undefined).
-  // Exposed for internal purposes only. Not considered part of the public API, and might be renamed eventually.
-  isClientSide?: boolean;
-  key?: SplitIO.SplitKey;
-}

package/src/utils/Backoff.ts

@@ -1,51 +0,0 @@
-export class Backoff {
-
-  // For testing purposes, assign to overwrite the provided value by param
-  static __TEST__BASE_MILLIS?: number;
-  static __TEST__MAX_MILLIS?: number;
-
-  static DEFAULT_BASE_MILLIS = 1000; // 1 second
-  static DEFAULT_MAX_MILLIS = 1800000; // 30 minutes
-
-  baseMillis: number;
-  maxMillis: number;
-  attempts: number;
-  cb: (...args: any[]) => any;
-  timeoutID: ReturnType<typeof setTimeout> | undefined;
-
-  /**
-   * Schedule function calls with exponential backoff
-   */
-  constructor(cb: (...args: any[]) => any, baseMillis?: number, maxMillis?: number) {
-    this.baseMillis = Backoff.__TEST__BASE_MILLIS || baseMillis || Backoff.DEFAULT_BASE_MILLIS;
-    this.maxMillis = Backoff.__TEST__MAX_MILLIS || maxMillis || Backoff.DEFAULT_MAX_MILLIS;
-    this.attempts = 0;
-    this.cb = cb;
-  }
-
-  /**
-   * Schedule a next call to `cb`
-   * @returns scheduled delay in milliseconds
-   */
-  scheduleCall() {
-    let delayInMillis = Math.min(this.baseMillis * Math.pow(2, this.attempts), this.maxMillis);
-
-    if (this.timeoutID) clearTimeout(this.timeoutID);
-    this.timeoutID = setTimeout(() => {
-      this.timeoutID = undefined;
-      this.cb();
-    }, delayInMillis);
-    this.attempts++;
-
-    return delayInMillis;
-  }
-
-  reset() {
-    this.attempts = 0;
-    if (this.timeoutID) {
-      clearTimeout(this.timeoutID);
-      this.timeoutID = undefined;
-    }
-  }
-
-}

package/src/utils/LRUCache/LinkedList.ts

@@ -1,130 +0,0 @@
-/* eslint-disable no-use-before-define */
-/**
- * yallist implementation based on isaacs/yallist (https://github.com/isaacs/yallist/yallist.js),
- * with the minimal features used by the SDK.
-
-Copyright (c) Isaac Z. Schlueter and Contributors
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
-IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-**/
-
-export class Node<T = any> {
-  value: T;
-  list: LinkedList<T> | null;
-  next: Node<T> | null;
-  prev: Node<T> | null;
-
-  constructor(value: T, prev: Node<T> | null, next: Node<T> | null, list: LinkedList<T> | null) {
-    this.list = list;
-    this.value = value;
-
-    if (prev) {
-      prev.next = this;
-      this.prev = prev;
-    } else {
-      this.prev = null;
-    }
-
-    if (next) {
-      next.prev = this;
-      this.next = next;
-    } else {
-      this.next = null;
-    }
-  }
-}
-
-export class LinkedList<T = any> {
-  tail: Node<T> | null;
-  head: Node<T> | null;
-  length: number;
-
-  constructor() {
-    this.tail = null;
-    this.head = null;
-    this.length = 0;
-  }
-
-  // removes the given node of `this` list and returns the next node.
-  removeNode(node: Node<T> | null): Node<T> | null | undefined {
-    if (!node || !(node instanceof Node)) return;
-
-    if (node.list !== this) {
-      throw new Error('removing node which does not belong to this list');
-    }
-
-    var next = node.next;
-    var prev = node.prev;
-
-    if (next) {
-      next.prev = prev;
-    }
-
-    if (prev) {
-      prev.next = next;
-    }
-
-    if (node === this.head) {
-      this.head = next;
-    }
-    if (node === this.tail) {
-      this.tail = prev;
-    }
-
-    node.list.length--;
-    node.next = null;
-    node.prev = null;
-    node.list = null;
-
-    return next;
-  }
-
-  // Move a Node object to the front of the list. (That is, pull it out of wherever it lives, and make it the new head.)
-  // If the node belongs to a different list, then that list will remove it first.
-  unshiftNode(node: Node<T>) {
-    if (!node || !(node instanceof Node)) return;
-
-    if (node === this.head) {
-      return;
-    }
-
-    if (node.list) {
-      node.list.removeNode(node);
-    }
-
-    var head = this.head;
-    node.list = this;
-    node.next = head;
-    if (head) {
-      head.prev = node;
-    }
-
-    this.head = node;
-    if (!this.tail) {
-      this.tail = node;
-    }
-    this.length++;
-  }
-
-  // similar to Array.prototype.unshift, it adds one or more elements to the head of the list and returns the new length of the list.
-  unshift() {
-    for (var i = 0, l = arguments.length; i < l; i++) {
-      this.head = new Node(arguments[i], null, this.head, this);
-      if (!this.tail) {
-        this.tail = this.head;
-      }
-      this.length++;
-    }
-    return this.length;
-  }
-}