@splitsoftware/splitio-commons 1.6.2-rc.0 → 1.6.2-rc.10

package/types/storages/types.d.ts

@@ -1,6 +1,6 @@
-import { MaybeThenable, IMetadata, ISplitFiltersValidation } from '../dtos/types';
+import { MaybeThenable, IMetadata, ISplitFiltersValidation, ISplit } from '../dtos/types';
 import { ILogger } from '../logger/types';
-import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent } from '../sync/submitters/types';
+import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs } from '../sync/submitters/types';
 import { SplitIO, ImpressionDTO, SDKMode } from '../types';
 /**
  * Interface of a pluggable storage wrapper.
@@ -65,23 +65,25 @@ export interface IPluggableStorageWrapper {
     getMany: (keys: string[]) => Promise<(string | null)[]>;
     /** Integer operations */
     /**
-     * Increments in 1 the given `key` value or set it to 1 if the value doesn't exist.
+     * Increments the number stored at `key` by `increment` (or 1 if `increment` is not provided), or set it to `increment` (or 1) if the value doesn't exist.
      *
      * @function incr
      * @param {string} key Key to increment
+     * @param {number} increment Value to increment by
      * @returns {Promise<number>} A promise that resolves with the value of key after the increment. The promise rejects if the operation fails,
      * for example, if there is a connection error or the key contains a string that can not be represented as integer.
      */
-    incr: (key: string) => Promise<number>;
+    incr: (key: string, increment?: number) => Promise<number>;
     /**
-     * Decrements in 1 the given `key` value or set it to -1 if the value doesn't exist.
+     * Decrements the number stored at `key` by `decrement` (or 1 if `decrement` is not provided), or set it to minus `decrement` (or minus 1) if the value doesn't exist.
      *
      * @function decr
      * @param {string} key Key to decrement
+     * @param {number} decrement Value to decrement by
      * @returns {Promise<number>} A promise that resolves with the value of key after the decrement. The promise rejects if the operation fails,
      * for example, if there is a connection error or the key contains a string that can not be represented as integer.
      */
-    decr: (key: string) => Promise<number>;
+    decr: (key: string, decrement?: number) => Promise<number>;
     /** Queue operations */
     /**
      * Inserts given items at the tail of `key` list. If `key` does not exist, an empty list is created before pushing the items.
@@ -178,13 +180,13 @@ export interface IPluggableStorageWrapper {
 }
 /** Splits cache */
 export interface ISplitsCacheBase {
-    addSplits(entries: [string, string][]): MaybeThenable<boolean[] | void>;
+    addSplits(entries: [string, ISplit][]): MaybeThenable<boolean[] | void>;
     removeSplits(names: string[]): MaybeThenable<boolean[] | void>;
-    getSplit(name: string): MaybeThenable<string | null>;
-    getSplits(names: string[]): MaybeThenable<Record<string, string | null>>;
+    getSplit(name: string): MaybeThenable<ISplit | null>;
+    getSplits(names: string[]): MaybeThenable<Record<string, ISplit | null>>;
     setChangeNumber(changeNumber: number): MaybeThenable<boolean | void>;
     getChangeNumber(): MaybeThenable<number>;
-    getAll(): MaybeThenable<string[]>;
+    getAll(): MaybeThenable<ISplit[]>;
     getSplitNames(): MaybeThenable<string[]>;
     trafficTypeExists(trafficType: string): MaybeThenable<boolean>;
     usesSegments(): MaybeThenable<boolean>;
@@ -193,13 +195,13 @@ export interface ISplitsCacheBase {
     killLocally(name: string, defaultTreatment: string, changeNumber: number): MaybeThenable<boolean>;
 }
 export interface ISplitsCacheSync extends ISplitsCacheBase {
-    addSplits(entries: [string, string][]): boolean[];
+    addSplits(entries: [string, ISplit][]): boolean[];
     removeSplits(names: string[]): boolean[];
-    getSplit(name: string): string | null;
-    getSplits(names: string[]): Record<string, string | null>;
+    getSplit(name: string): ISplit | null;
+    getSplits(names: string[]): Record<string, ISplit | null>;
     setChangeNumber(changeNumber: number): boolean;
     getChangeNumber(): number;
-    getAll(): string[];
+    getAll(): ISplit[];
     getSplitNames(): string[];
     trafficTypeExists(trafficType: string): boolean;
     usesSegments(): boolean;
@@ -208,13 +210,13 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
     killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean;
 }
 export interface ISplitsCacheAsync extends ISplitsCacheBase {
-    addSplits(entries: [string, string][]): Promise<boolean[] | void>;
+    addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>;
     removeSplits(names: string[]): Promise<boolean[] | void>;
-    getSplit(name: string): Promise<string | null>;
-    getSplits(names: string[]): Promise<Record<string, string | null>>;
+    getSplit(name: string): Promise<ISplit | null>;
+    getSplits(names: string[]): Promise<Record<string, ISplit | null>>;
     setChangeNumber(changeNumber: number): Promise<boolean | void>;
     getChangeNumber(): Promise<number>;
-    getAll(): Promise<string[]>;
+    getAll(): Promise<ISplit[]>;
     getSplitNames(): Promise<string[]>;
     trafficTypeExists(trafficType: string): Promise<boolean>;
     usesSegments(): Promise<boolean>;
@@ -297,6 +299,13 @@ export interface IImpressionCountsCacheSync extends IRecorderCacheProducerSync<R
     isEmpty(): boolean;
     pop(toMerge?: Record<string, number>): Record<string, number>;
 }
+export interface IUniqueKeysCacheBase {
+    track(key: string, value: string): void;
+    isEmpty(): boolean;
+    pop(): UniqueKeysPayloadSs | UniqueKeysPayloadCs;
+    setOnFullQueueCb(cb: () => void): void;
+    clear(): void;
+}
 /**
  * Telemetry storage interface for standalone and partial consumer modes.
  * Methods are sync because data is stored in memory.
@@ -354,31 +363,34 @@ export interface ITelemetryCacheSync extends ITelemetryStorageConsumerSync, ITel
  * Methods are async because data is stored in Redis or a pluggable storage.
  */
 export interface ITelemetryEvaluationConsumerAsync {
-    popExceptions(): Promise<MethodExceptions>;
-    popLatencies(): Promise<MethodLatencies>;
+    popLatencies(): Promise<MultiMethodLatencies>;
+    popExceptions(): Promise<MultiMethodExceptions>;
+    popConfigs(): Promise<MultiConfigs>;
 }
 export interface ITelemetryEvaluationProducerAsync {
     recordLatency(method: Method, latencyMs: number): Promise<any>;
     recordException(method: Method): Promise<any>;
+    recordConfig(): Promise<any>;
 }
-export interface ITelemetryCacheAsync extends ITelemetryEvaluationProducerAsync {
+export interface ITelemetryCacheAsync extends ITelemetryEvaluationProducerAsync, ITelemetryEvaluationConsumerAsync {
 }
 /**
  * Storages
  */
-export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCache extends ISegmentsCacheBase, TImpressionsCache extends IImpressionsCacheBase, TEventsCache extends IEventsCacheBase, TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync> {
+export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCache extends ISegmentsCacheBase, TImpressionsCache extends IImpressionsCacheBase, TImpressionsCountCache extends IImpressionCountsCacheSync, TEventsCache extends IEventsCacheBase, TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync, TUniqueKeysCache extends IUniqueKeysCacheBase> {
     splits: TSplitsCache;
     segments: TSegmentsCache;
     impressions: TImpressionsCache;
-    impressionCounts?: IImpressionCountsCacheSync;
+    impressionCounts?: TImpressionsCountCache;
     events: TEventsCache;
     telemetry?: TTelemetryCache;
+    uniqueKeys?: TUniqueKeysCache;
     destroy(): void | Promise<void>;
     shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this;
 }
-export interface IStorageSync extends IStorageBase<ISplitsCacheSync, ISegmentsCacheSync, IImpressionsCacheSync, IEventsCacheSync, ITelemetryCacheSync> {
+export interface IStorageSync extends IStorageBase<ISplitsCacheSync, ISegmentsCacheSync, IImpressionsCacheSync, IImpressionCountsCacheSync, IEventsCacheSync, ITelemetryCacheSync, IUniqueKeysCacheBase> {
 }
-export interface IStorageAsync extends IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync | IImpressionsCacheSync, IEventsCacheAsync | IEventsCacheSync, ITelemetryCacheAsync> {
+export interface IStorageAsync extends IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync | IImpressionsCacheSync, IImpressionCountsCacheSync, IEventsCacheAsync | IEventsCacheSync, ITelemetryCacheAsync | ITelemetryCacheSync, IUniqueKeysCacheBase> {
 }
 /** StorageFactory */
 export declare type DataLoader = (storage: IStorageSync, matchingKey: string) => void;
@@ -388,6 +400,7 @@ export interface IStorageFactoryParams {
     eventsQueueSize?: number;
     optimize?: boolean;
     mode: SDKMode;
+    impressionsMode?: string;
     matchingKey?: string;
     splitFiltersValidation?: ISplitFiltersValidation;
     onReadyCb: (error?: any) => void;

package/types/sync/polling/updaters/splitChangesUpdater.d.ts

@@ -11,7 +11,7 @@ declare type ISplitChangesUpdater = (noCache?: boolean, till?: number) => Promis
  */
 export declare function parseSegments({ conditions }: ISplit): ISet<string>;
 interface ISplitMutations {
-    added: [string, string][];
+    added: [string, ISplit][];
     removed: string[];
     segments: string[];
 }

package/types/sync/submitters/telemetrySubmitter.d.ts

@@ -5,7 +5,7 @@ import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 /**
  * Converts data from telemetry cache into /metrics/usage request payload.
  */
-export declare function telemetryCacheStatsAdapter(telemetry: ITelemetryCacheSync, splits: ISplitsCacheSync, segments: ISegmentsCacheSync): {
+export declare function telemetryCacheStatsAdapter(telemetry: ITelemetryCacheSync, splits?: ISplitsCacheSync, segments?: ISegmentsCacheSync): {
     isEmpty(): boolean;
     clear(): void;
     pop(): TelemetryUsageStatsPayload;

package/types/sync/submitters/types.d.ts

@@ -1,5 +1,6 @@
 import { IMetadata } from '../../dtos/types';
 import { SplitIO } from '../../types';
+import { IMap } from '../../utils/lang/maps';
 import { ISyncTask } from '../types';
 export declare type ImpressionsPayload = {
     /** Split name */
@@ -32,6 +33,22 @@ export declare type ImpressionCountsPayload = {
         rc: number;
     }[];
 };
+export declare type UniqueKeysPayloadSs = {
+    keys: {
+        /** Split name */
+        f: string;
+        /** keyNames */
+        ks: string[];
+    }[];
+};
+export declare type UniqueKeysPayloadCs = {
+    keys: {
+        /** keyNames */
+        k: string;
+        /** Split name */
+        fs: string[];
+    }[];
+};
 export declare type StoredImpressionWithMetadata = {
     /** Metadata */
     m: IMetadata;
@@ -59,6 +76,9 @@ export declare type StoredEventWithMetadata = {
     /** Stored event */
     e: SplitIO.EventData;
 };
+export declare type MultiMethodLatencies = IMap<string, MethodLatencies>;
+export declare type MultiMethodExceptions = IMap<string, MethodExceptions>;
+export declare type MultiConfigs = IMap<string, TelemetryConfigStats>;
 /**
  * Telemetry usage stats
  */
@@ -103,10 +123,12 @@ export declare type StreamingEvent = {
     d?: number;
     t: number;
 };
-export declare type TelemetryUsageStatsPayload = {
+export declare type TelemetryUsageStats = {
+    mL?: MethodLatencies;
+    mE?: MethodExceptions;
+};
+export declare type TelemetryUsageStatsPayload = TelemetryUsageStats & {
     lS: LastSync;
-    mL: MethodLatencies;
-    mE: MethodExceptions;
     hE: HttpErrors;
     hL: HttpLatencies;
     tR: number;
@@ -114,9 +136,9 @@ export declare type TelemetryUsageStatsPayload = {
     iQ: number;
     iDe: number;
     iDr: number;
-    spC: number;
-    seC: number;
-    skC: number;
+    spC?: number;
+    seC?: number;
+    skC?: number;
     sL?: number;
     eQ: number;
     eD: number;
@@ -132,7 +154,8 @@ export declare type CONSUMER_PARTIAL_ENUM = 2;
 export declare type OperationMode = STANDALONE_ENUM | CONSUMER_ENUM | CONSUMER_PARTIAL_ENUM;
 export declare type OPTIMIZED_ENUM = 0;
 export declare type DEBUG_ENUM = 1;
-export declare type ImpressionsMode = OPTIMIZED_ENUM | DEBUG_ENUM;
+export declare type NONE_ENUM = 2;
+export declare type ImpressionsMode = OPTIMIZED_ENUM | DEBUG_ENUM | NONE_ENUM;
 export declare type RefreshRates = {
     sp: number;
     se?: number;

package/types/sync/submitters/uniqueKeysSubmitter.d.ts

@@ -1,12 +1,4 @@
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
-import { ISet } from '../../utils/lang/sets';
-import { UniqueKeysPayload } from './types';
-/**
- * Converts `uniqueKeys` data from cache into request payload.
- */
-export declare function fromUniqueKeysCollector(uniqueKeys: {
-    [featureName: string]: ISet<string>;
-}): UniqueKeysPayload;
 /**
  * Submitter that periodically posts impression counts
  */

package/types/trackers/impressionsTracker.d.ts

@@ -1,7 +1,6 @@
-import { IImpressionCountsCacheSync, IImpressionsCacheBase, ITelemetryCacheSync, ITelemetryCacheAsync } from '../storages/types';
-import { IImpressionsHandler, IImpressionsTracker } from './types';
+import { IImpressionsCacheBase, ITelemetryCacheSync, ITelemetryCacheAsync } from '../storages/types';
+import { IImpressionsHandler, IImpressionsTracker, IStrategy } from './types';
 import { ISettings } from '../types';
-import { IImpressionObserver } from './impressionObserver/types';
 /**
  * Impressions tracker stores impressions in cache and pass them to the listener and integrations manager if provided.
  *
@@ -9,7 +8,6 @@ import { IImpressionObserver } from './impressionObserver/types';
  * @param metadata runtime metadata (ip, hostname and version)
  * @param impressionListener optional impression listener
  * @param integrationsManager optional integrations manager
- * @param observer optional impression observer. If provided, previous time (pt property) is included in impression instances
- * @param countsCache optional cache to save impressions count. If provided, impressions will be deduped (OPTIMIZED mode)
+ * @param strategy strategy for impressions tracking.
  */
-export declare function impressionsTrackerFactory(settings: ISettings, impressionsCache: IImpressionsCacheBase, integrationsManager?: IImpressionsHandler, observer?: IImpressionObserver, countsCache?: IImpressionCountsCacheSync, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IImpressionsTracker;
+export declare function impressionsTrackerFactory(settings: ISettings, impressionsCache: IImpressionsCacheBase, strategy: IStrategy, integrationsManager?: IImpressionsHandler, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IImpressionsTracker;

package/types/trackers/types.d.ts

@@ -33,4 +33,31 @@ export interface ITelemetryTracker {
      * Records streaming event
      */
     streamingEvent(e: StreamingEventType | AUTH_REJECTION, d?: number): void;
+    /**
+     * Records tag
+     */
+    addTag(tag: string): 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 {
+    stop(): void;
+    track(key: string, featureName: string): void;
+}
+export interface IStrategyResult {
+    impressionsToStore: ImpressionDTO[];
+    impressionsToListener: ImpressionDTO[];
+    deduped: number;
+}
+export interface IStrategy {
+    process(impressions: ImpressionDTO[]): IStrategyResult;
 }

package/types/trackers/uniqueKeysTracker.d.ts

@@ -1,4 +1,5 @@
 import { ILogger } from '../logger/types';
+import { IUniqueKeysCacheBase } from '../storages/types';
 import { IFilterAdapter, IUniqueKeysTracker } from './types';
 /**
  * Trackes uniques keys
@@ -6,8 +7,7 @@ import { IFilterAdapter, IUniqueKeysTracker } from './types';
  *  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
- * @param cacheSize optional internal cache size
- * @param maxBulkSize optional max MTKs bulk size
  */
-export declare function uniqueKeysTrackerFactory(log: ILogger, filterAdapter?: IFilterAdapter, cacheSize?: number): IUniqueKeysTracker;
+export declare function uniqueKeysTrackerFactory(log: ILogger, uniqueKeysCache: IUniqueKeysCacheBase, filterAdapter?: IFilterAdapter): IUniqueKeysTracker;

package/types/types.d.ts

@@ -715,7 +715,7 @@ export declare namespace SplitIO {
     * ImpressionsMode type
     * @typedef {string} ImpressionsMode
     */
-    type ImpressionsMode = 'OPTIMIZED' | 'DEBUG';
+    type ImpressionsMode = 'OPTIMIZED' | 'DEBUG' | 'NONE';
     /**
      * Defines the format of Split data to preload on the factory storage (cache).
      */

package/types/utils/constants/index.d.ts

@@ -11,6 +11,7 @@ export declare const SPLIT_IMPRESSION = "IMPRESSION";
 export declare const SPLIT_EVENT = "EVENT";
 export declare const DEBUG = "DEBUG";
 export declare const OPTIMIZED = "OPTIMIZED";
+export declare const NONE = "NONE";
 export declare const LOCALHOST_MODE: SDKMode;
 export declare const STANDALONE_MODE: SDKMode;
 export declare const PRODUCER_MODE = "producer";
@@ -31,6 +32,7 @@ export declare const CONSUMER_ENUM = 1;
 export declare const CONSUMER_PARTIAL_ENUM = 2;
 export declare const OPTIMIZED_ENUM = 0;
 export declare const DEBUG_ENUM = 1;
+export declare const NONE_ENUM = 2;
 export declare const SPLITS = "sp";
 export declare const IMPRESSIONS = "im";
 export declare const IMPRESSIONS_COUNT = "ic";

package/types/utils/lang/maps.d.ts

@@ -23,10 +23,12 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 **/
 export interface IMap<K, V> {
-    set(key: K, value: V): this;
     clear(): void;
     delete(key: K): boolean;
+    forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
     get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): this;
     readonly size: number;
 }
 export declare class MapPoly<K, V> implements IMap<K, V> {
@@ -34,9 +36,11 @@ export declare class MapPoly<K, V> implements IMap<K, V> {
     private __mapValuesData__;
     constructor(entries?: readonly (readonly [K, V])[] | null);
     clear(): void;
-    set(key: K, value: V): this;
     delete(key: K): boolean;
+    forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
     get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): this;
     get size(): number;
 }
 interface IMapConstructor {

package/types/utils/redis/RedisMock.d.ts

@@ -0,0 +1,4 @@
+export declare class RedisMock {
+    private pipelineMethods;
+    constructor();
+}