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

package/types/storages/AbstractSplitsCacheAsync.d.ts

@@ -1,17 +1,18 @@
 import { ISplitsCacheAsync } from './types';
+import { ISplit } from '../dtos/types';
 /**
  * This class provides a skeletal implementation of the ISplitsCacheAsync interface
  * to minimize the effort required to implement this interface.
  */
 export declare abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
-    abstract addSplit(name: string, split: string): Promise<boolean>;
-    abstract addSplits(entries: [string, string][]): Promise<boolean[] | void>;
+    abstract addSplit(name: string, split: ISplit): Promise<boolean>;
+    abstract addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>;
     abstract removeSplits(names: string[]): Promise<boolean[] | void>;
-    abstract getSplit(name: string): Promise<string | null>;
-    abstract getSplits(names: string[]): Promise<Record<string, string | null>>;
+    abstract getSplit(name: string): Promise<ISplit | null>;
+    abstract getSplits(names: string[]): Promise<Record<string, ISplit | null>>;
     abstract setChangeNumber(changeNumber: number): Promise<boolean | void>;
     abstract getChangeNumber(): Promise<number>;
-    abstract getAll(): Promise<string[]>;
+    abstract getAll(): Promise<ISplit[]>;
     abstract getSplitNames(): Promise<string[]>;
     abstract trafficTypeExists(trafficType: string): Promise<boolean>;
     abstract clear(): Promise<boolean | void>;
@@ -28,7 +29,7 @@ export declare abstract class AbstractSplitsCacheAsync implements ISplitsCacheAs
      * @param {string} name
      * @param {string} defaultTreatment
      * @param {number} changeNumber
-     * @returns {Promise} a promise that is resolved once the split kill operation is performed. The fulfillment value is a boolean: `true` if the kill success updating the split or `false` if no split is updated,
+     * @returns {Promise} a promise that is resolved once the split kill operation is performed. The fulfillment value is a boolean: `true` if the operation successed updating the split or `false` if no split is updated,
      * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
      * The promise will never be rejected.
      */

package/types/storages/AbstractSplitsCacheSync.d.ts

@@ -5,15 +5,15 @@ import { ISplit } from '../dtos/types';
  * to minimize the effort required to implement this interface.
  */
 export declare abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
-    abstract addSplit(name: string, split: string): boolean;
-    addSplits(entries: [string, string][]): boolean[];
+    abstract addSplit(name: string, split: ISplit): boolean;
+    addSplits(entries: [string, ISplit][]): boolean[];
     abstract removeSplit(name: string): boolean;
     removeSplits(names: string[]): boolean[];
-    abstract getSplit(name: string): string | null;
-    getSplits(names: string[]): Record<string, string | null>;
+    abstract getSplit(name: string): ISplit | null;
+    getSplits(names: string[]): Record<string, ISplit | null>;
     abstract setChangeNumber(changeNumber: number): boolean;
     abstract getChangeNumber(): number;
-    getAll(): string[];
+    getAll(): ISplit[];
     abstract getSplitNames(): string[];
     abstract trafficTypeExists(trafficType: string): boolean;
     abstract usesSegments(): boolean;
@@ -30,7 +30,7 @@ export declare abstract class AbstractSplitsCacheSync implements ISplitsCacheSyn
      * @param {string} name
      * @param {string} defaultTreatment
      * @param {number} changeNumber
-     * @returns {Promise} a promise that is resolved once the split kill is performed. The fulfillment value is a boolean: `true` if the kill success updating the split or `false` if no split is updated,
+     * @returns {boolean} `true` if the operation successed updating the split, or `false` if no split is updated,
      * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
      */
     killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean;

package/types/storages/KeyBuilderSS.d.ts

@@ -2,14 +2,21 @@ import { KeyBuilder } from './KeyBuilder';
 import { IMetadata } from '../dtos/types';
 import { Method } from '../sync/submitters/types';
 export declare class KeyBuilderSS extends KeyBuilder {
-    protected readonly metadata: IMetadata;
+    latencyPrefix: string;
+    exceptionPrefix: string;
+    initPrefix: string;
+    private versionablePrefix;
     constructor(prefix: string, metadata: IMetadata);
     buildRegisteredSegmentsKey(): string;
     buildImpressionsKey(): string;
+    buildImpressionsCountKey(): string;
+    buildUniqueKeysKey(): string;
     buildEventsKey(): string;
     searchPatternForSplitKeys(): string;
     buildLatencyKey(method: Method, bucket: number): string;
     buildExceptionKey(method: Method): string;
     buildInitKey(): string;
-    private buildVersionablePrefix;
 }
+export declare function parseMetadata(field: string): [metadata: string] | string;
+export declare function parseExceptionField(field: string): [metadata: string, method: Method] | string;
+export declare function parseLatencyField(field: string): [metadata: string, method: Method, bucket: number] | string;

package/types/storages/inLocalStorage/SplitsCacheInLocal.d.ts

@@ -1,4 +1,4 @@
-import { ISplitFiltersValidation } from '../../dtos/types';
+import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { AbstractSplitsCacheSync } from '../AbstractSplitsCacheSync';
 import { KeyBuilderCS } from '../KeyBuilderCS';
 import { ILogger } from '../../logger/types';
@@ -26,9 +26,9 @@ export declare class SplitsCacheInLocal extends AbstractSplitsCacheSync {
      * We cannot simply call `localStorage.clear()` since that implies removing user items from the storage.
      */
     clear(): void;
-    addSplit(name: string, split: string): boolean;
+    addSplit(name: string, split: ISplit): boolean;
     removeSplit(name: string): boolean;
-    getSplit(name: string): string | null;
+    getSplit(name: string): any;
     setChangeNumber(changeNumber: number): boolean;
     getChangeNumber(): number;
     getSplitNames(): string[];
@@ -42,7 +42,6 @@ export declare class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     checkCache(): boolean;
     /**
      * Clean Splits cache if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
-     * Clean operation (clear) also updates `lastUpdated` timestamp with current time.
      *
      * @param {number | undefined} expirationTimestamp if the value is not a number, data will not be cleaned
      */

package/types/storages/inMemory/ImpressionCountsCacheInMemory.d.ts

@@ -1,6 +1,10 @@
 import { IImpressionCountsCacheSync } from '../types';
 export declare class ImpressionCountsCacheInMemory implements IImpressionCountsCacheSync {
-    private cache;
+    protected cache: Record<string, number>;
+    private readonly maxStorage;
+    protected onFullQueue?: () => void;
+    private cacheSize;
+    constructor(impressionCountsCacheSize?: number);
     /**
     * Builds key to be stored in the cache with the featureName and the timeFrame truncated.
     */

package/types/storages/inMemory/SplitsCacheInMemory.d.ts

@@ -1,3 +1,4 @@
+import { ISplit } from '../../dtos/types';
 import { AbstractSplitsCacheSync } from '../AbstractSplitsCacheSync';
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
@@ -9,9 +10,9 @@ export declare class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     private changeNumber;
     private splitsWithSegmentsCount;
     clear(): void;
-    addSplit(name: string, split: string): boolean;
+    addSplit(name: string, split: ISplit): boolean;
     removeSplit(name: string): boolean;
-    getSplit(name: string): string | null;
+    getSplit(name: string): ISplit | null;
     setChangeNumber(changeNumber: number): boolean;
     getChangeNumber(): number;
     getSplitNames(): string[];

package/types/storages/inMemory/TelemetryCacheInMemory.d.ts

@@ -1,9 +1,12 @@
 import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies, StreamingEvent, Method, OperationType, MethodExceptions, MethodLatencies } from '../../sync/submitters/types';
-import { ITelemetryCacheSync } from '../types';
+import { IStorageFactoryParams, ITelemetryCacheSync } from '../types';
+export declare const MAX_LATENCY_BUCKET_COUNT = 23;
+export declare function newBuckets(): number[];
 /**
- * Used on client-side. 0.1% of instances will track telemetry
+ * Record telemetry if mode is not localhost.
+ * All factory instances track telemetry on server-side, and 0.1% on client-side.
  */
-export declare function shouldRecordTelemetry(): boolean;
+export declare function shouldRecordTelemetry(params: IStorageFactoryParams): boolean;
 export declare class TelemetryCacheInMemory implements ITelemetryCacheSync {
     private timeUntilReady?;
     getTimeUntilReady(): number | undefined;

package/types/storages/inMemory/uniqueKeysCacheInMemory.d.ts

@@ -0,0 +1,35 @@
+import { IUniqueKeysCacheBase } from '../types';
+import { ISet } from '../../utils/lang/sets';
+import { UniqueKeysPayloadSs } from '../../sync/submitters/types';
+export declare class UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
+    protected onFullQueue?: () => void;
+    private readonly maxStorage;
+    private uniqueTrackerSize;
+    protected uniqueKeysTracker: {
+        [keys: string]: ISet<string>;
+    };
+    constructor(uniqueKeysQueueSize?: number);
+    setOnFullQueueCb(cb: () => void): void;
+    /**
+     * Store unique keys in sequential order
+     * key: string = feature name.
+     * value: Set<string> = set of unique keys.
+     */
+    track(key: string, featureName: string): void;
+    /**
+     * Clear the data stored on the cache.
+     */
+    clear(): void;
+    /**
+     * Pop the collected data, used as payload for posting.
+     */
+    pop(): UniqueKeysPayloadSs;
+    /**
+     * Check if the cache is empty.
+     */
+    isEmpty(): boolean;
+    /**
+     * Converts `uniqueKeys` data from cache into request payload for SS.
+     */
+    private fromUniqueKeysCollector;
+}

package/types/storages/inMemory/uniqueKeysCacheInMemoryCS.d.ts

@@ -0,0 +1,37 @@
+import { IUniqueKeysCacheBase } from '../types';
+import { UniqueKeysPayloadCs } from '../../sync/submitters/types';
+export declare class UniqueKeysCacheInMemoryCS implements IUniqueKeysCacheBase {
+    private onFullQueue?;
+    private readonly maxStorage;
+    private uniqueTrackerSize;
+    private uniqueKeysTracker;
+    /**
+     *
+     * @param impressionsQueueSize number of queued impressions to call onFullQueueCb.
+     * Default value is 0, that means no maximum value, in case we want to avoid this being triggered.
+     */
+    constructor(uniqueKeysQueueSize?: number);
+    setOnFullQueueCb(cb: () => void): void;
+    /**
+     * Store unique keys in sequential order
+     * key: string = key.
+     * value: HashSet<string> = set of split names.
+     */
+    track(key: string, featureName: string): void;
+    /**
+     * Clear the data stored on the cache.
+     */
+    clear(): void;
+    /**
+     * Pop the collected data, used as payload for posting.
+     */
+    pop(): UniqueKeysPayloadCs;
+    /**
+     * Check if the cache is empty.
+     */
+    isEmpty(): boolean;
+    /**
+     * Converts `uniqueKeys` data from cache into request payload.
+     */
+    private fromUniqueKeysCollector;
+}

package/types/storages/inRedis/EventsCacheInRedis.d.ts

@@ -23,7 +23,7 @@ export declare class EventsCacheInRedis implements IEventsCacheAsync {
     drop(count?: number): Promise<any>;
     /**
      * Pop the given number of events from the storage.
-     * The returned promise rejects if the wrapper operation fails.
+     * The returned promise rejects if the redis operation fails.
      *
      * NOTE: this method doesn't take into account MAX_EVENT_SIZE or MAX_QUEUE_BYTE_SIZE limits.
      * It is the submitter responsability to handle that.

package/types/storages/inRedis/ImpressionCountsCacheInRedis.d.ts

@@ -0,0 +1,14 @@
+import { Redis } from 'ioredis';
+import { ILogger } from '../../logger/types';
+import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
+export declare class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory {
+    private readonly log;
+    private readonly key;
+    private readonly redis;
+    private readonly refreshRate;
+    private intervalId;
+    constructor(log: ILogger, key: string, redis: Redis, impressionCountsCacheSize?: number, refreshRate?: number);
+    private postImpressionCountsInRedis;
+    start(): void;
+    stop(): Promise<boolean | import("ioredis").BooleanResponse | undefined>;
+}

package/types/storages/inRedis/SplitsCacheInRedis.d.ts

@@ -1,6 +1,7 @@
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { Redis } from 'ioredis';
 import { ILogger } from '../../logger/types';
+import { ISplit } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
 /**
  * ISplitsCacheAsync implementation that stores split definitions in Redis.
@@ -19,13 +20,13 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
      * The returned promise is resolved when the operation success
      * or rejected if it fails (e.g., redis operation fails)
      */
-    addSplit(name: string, split: string): Promise<boolean>;
+    addSplit(name: string, split: ISplit): Promise<boolean>;
     /**
      * Add a list of splits.
      * The returned promise is resolved when the operation success
      * or rejected if it fails (e.g., redis operation fails)
      */
-    addSplits(entries: [string, string][]): Promise<boolean[]>;
+    addSplits(entries: [string, ISplit][]): Promise<boolean[]>;
     /**
      * Remove a given split.
      * The returned promise is resolved when the operation success, with 1 or 0 indicating if the split existed or not.
@@ -42,7 +43,7 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
      * Get split definition or null if it's not defined.
      * Returned promise is rejected if redis operation fails.
      */
-    getSplit(name: string): Promise<string | null>;
+    getSplit(name: string): Promise<ISplit | null>;
     /**
      * Set till number.
      * The returned promise is resolved when the operation success,
@@ -63,7 +64,7 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
      * @TODO we need to benchmark which is the maximun number of commands we could
      *       pipeline without kill redis performance.
      */
-    getAll(): Promise<string[]>;
+    getAll(): Promise<ISplit[]>;
     /**
      * Get list of split names.
      * The returned promise is resolved with the list of split names,
@@ -87,5 +88,5 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
      * Fetches multiple splits definitions.
      * Returned promise is rejected if redis operation fails.
      */
-    getSplits(names: string[]): Promise<Record<string, string | null>>;
+    getSplits(names: string[]): Promise<Record<string, ISplit | null>>;
 }

package/types/storages/inRedis/TelemetryCacheInRedis.d.ts

@@ -1,5 +1,5 @@
 import { ILogger } from '../../logger/types';
-import { Method } from '../../sync/submitters/types';
+import { Method, MultiConfigs, MultiMethodExceptions, MultiMethodLatencies } from '../../sync/submitters/types';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { ITelemetryCacheAsync } from '../types';
 import { Redis } from 'ioredis';
@@ -17,4 +17,19 @@ export declare class TelemetryCacheInRedis implements ITelemetryCacheAsync {
     recordLatency(method: Method, latencyMs: number): Promise<number | void>;
     recordException(method: Method): Promise<number | void>;
     recordConfig(): Promise<number | void>;
+    /**
+     * Pop telemetry latencies.
+     * The returned promise rejects if redis operations fail.
+     */
+    popLatencies(): Promise<MultiMethodLatencies>;
+    /**
+     * Pop telemetry exceptions.
+     * The returned promise rejects if redis operations fail.
+     */
+    popExceptions(): Promise<MultiMethodExceptions>;
+    /**
+     * Pop telemetry configs.
+     * The returned promise rejects if redis operations fail.
+     */
+    popConfigs(): Promise<MultiConfigs>;
 }

package/types/storages/inRedis/constants.d.ts

@@ -1 +1,4 @@
 export declare const LOG_PREFIX = "storage:redis: ";
+export declare const DEFAULT_CACHE_SIZE = 30000;
+export declare const REFRESH_RATE = 300000;
+export declare const TTL_REFRESH = 3600;

package/types/storages/inRedis/uniqueKeysCacheInRedis.d.ts

@@ -0,0 +1,15 @@
+import { IUniqueKeysCacheBase } from '../types';
+import { Redis } from 'ioredis';
+import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
+import { ILogger } from '../../logger/types';
+export declare class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
+    private readonly log;
+    private readonly key;
+    private readonly redis;
+    private readonly refreshRate;
+    private intervalId;
+    constructor(log: ILogger, key: string, redis: Redis, uniqueKeysQueueSize?: number, refreshRate?: number);
+    private postUniqueKeysInRedis;
+    start(): void;
+    stop(): Promise<boolean | import("ioredis").BooleanResponse | undefined>;
+}

package/types/storages/pluggable/ImpressionCountsCachePluggable.d.ts

@@ -0,0 +1,14 @@
+import { ILogger } from '../../logger/types';
+import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
+import { IPluggableStorageWrapper } from '../types';
+export declare class ImpressionCountsCachePluggable extends ImpressionCountsCacheInMemory {
+    private readonly log;
+    private readonly key;
+    private readonly wrapper;
+    private readonly refreshRate;
+    private intervalId;
+    constructor(log: ILogger, key: string, wrapper: IPluggableStorageWrapper, impressionCountsCacheSize?: number, refreshRate?: number);
+    private storeImpressionCounts;
+    start(): void;
+    stop(): Promise<any>;
+}

package/types/storages/pluggable/SplitsCachePluggable.d.ts

@@ -1,6 +1,7 @@
 import { KeyBuilder } from '../KeyBuilder';
 import { IPluggableStorageWrapper } from '../types';
 import { ILogger } from '../../logger/types';
+import { ISplit } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
 /**
  * ISplitsCacheAsync implementation for pluggable storages.
@@ -23,13 +24,13 @@ export declare class SplitsCachePluggable extends AbstractSplitsCacheAsync {
      * The returned promise is resolved when the operation success
      * or rejected if it fails (e.g., wrapper operation fails)
      */
-    addSplit(name: string, split: string): Promise<boolean>;
+    addSplit(name: string, split: ISplit): Promise<boolean>;
     /**
      * Add a list of splits.
      * The returned promise is resolved when the operation success
      * or rejected if it fails (e.g., wrapper operation fails)
      */
-    addSplits(entries: [string, string][]): Promise<boolean[]>;
+    addSplits(entries: [string, ISplit][]): Promise<boolean[]>;
     /**
      * Remove a given split.
      * The returned promise is resolved when the operation success, with a boolean indicating if the split existed or not.
@@ -47,19 +48,19 @@ export declare class SplitsCachePluggable extends AbstractSplitsCacheAsync {
      * The returned promise is resolved with the split definition or null if it's not defined,
      * or rejected if wrapper operation fails.
      */
-    getSplit(name: string): Promise<string | null>;
+    getSplit(name: string): Promise<ISplit | null>;
     /**
      * Get list of splits.
      * The returned promise is resolved with a map of split names to their split definition or null if it's not defined,
      * or rejected if wrapper operation fails.
      */
-    getSplits(names: string[]): Promise<Record<string, string | null>>;
+    getSplits(names: string[]): Promise<Record<string, ISplit | null>>;
     /**
      * Get list of all split definitions.
      * The returned promise is resolved with the list of split definitions,
      * or rejected if wrapper operation fails.
      */
-    getAll(): Promise<string[]>;
+    getAll(): Promise<ISplit[]>;
     /**
      * Get list of split names.
      * The returned promise is resolved with the list of split names,

package/types/storages/pluggable/TelemetryCachePluggable.d.ts

@@ -1,5 +1,5 @@
 import { ILogger } from '../../logger/types';
-import { Method } from '../../sync/submitters/types';
+import { Method, MultiConfigs, MultiMethodExceptions, MultiMethodLatencies } from '../../sync/submitters/types';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { IPluggableStorageWrapper, ITelemetryCacheAsync } from '../types';
 export declare class TelemetryCachePluggable implements ITelemetryCacheAsync {
@@ -15,4 +15,20 @@ export declare class TelemetryCachePluggable implements ITelemetryCacheAsync {
     constructor(log: ILogger, keys: KeyBuilderSS, wrapper: IPluggableStorageWrapper);
     recordLatency(method: Method, latencyMs: number): Promise<number | void>;
     recordException(method: Method): Promise<number | void>;
+    recordConfig(): Promise<boolean | void>;
+    /**
+     * Pop telemetry latencies.
+     * The returned promise rejects if wrapper operations fail.
+     */
+    popLatencies(): Promise<MultiMethodLatencies>;
+    /**
+     * Pop telemetry exceptions.
+     * The returned promise rejects if wrapper operations fail.
+     */
+    popExceptions(): Promise<MultiMethodExceptions>;
+    /**
+     * Pop telemetry configs.
+     * The returned promise rejects if wrapper operations fail.
+     */
+    popConfigs(): Promise<MultiConfigs>;
 }

package/types/storages/pluggable/UniqueKeysCachePluggable.d.ts

@@ -0,0 +1,14 @@
+import { IPluggableStorageWrapper, IUniqueKeysCacheBase } from '../types';
+import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
+import { ILogger } from '../../logger/types';
+export declare class UniqueKeysCachePluggable extends UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
+    private readonly log;
+    private readonly key;
+    private readonly wrapper;
+    private readonly refreshRate;
+    private intervalId;
+    constructor(log: ILogger, key: string, wrapper: IPluggableStorageWrapper, uniqueKeysQueueSize?: number, refreshRate?: number);
+    storeUniqueKeys(): Promise<any>;
+    start(): void;
+    stop(): Promise<any>;
+}

package/types/storages/types.d.ts

@@ -1,8 +1,7 @@
-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';
-import { ISet } from '../utils/lang/sets';
 /**
  * Interface of a pluggable storage wrapper.
  */
@@ -66,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.
@@ -179,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>;
@@ -194,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;
@@ -209,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>;
@@ -298,16 +299,12 @@ export interface IImpressionCountsCacheSync extends IRecorderCacheProducerSync<R
     isEmpty(): boolean;
     pop(toMerge?: Record<string, number>): Record<string, number>;
 }
-export interface IUniqueKeysCacheBase extends IRecorderCacheProducerSync<{
-    [featureName: string]: ISet<string>;
-}> {
-    track(featureName: string, timeFrame: number, amount: number): void;
+export interface IUniqueKeysCacheBase {
+    track(key: string, value: string): void;
     isEmpty(): boolean;
-    pop(toMerge?: {
-        [featureName: string]: ISet<string>;
-    }): {
-        [featureName: string]: ISet<string>;
-    };
+    pop(): UniqueKeysPayloadSs | UniqueKeysPayloadCs;
+    setOnFullQueueCb(cb: () => void): void;
+    clear(): void;
 }
 /**
  * Telemetry storage interface for standalone and partial consumer modes.
@@ -366,32 +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, TUniqueKeysCache extends IUniqueKeysCacheBase> {
+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, IUniqueKeysCacheBase> {
+export interface IStorageSync extends IStorageBase<ISplitsCacheSync, ISegmentsCacheSync, IImpressionsCacheSync, IImpressionCountsCacheSync, IEventsCacheSync, ITelemetryCacheSync, IUniqueKeysCacheBase> {
 }
-export interface IStorageAsync extends IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync | IImpressionsCacheSync, IEventsCacheAsync | IEventsCacheSync, ITelemetryCacheAsync, IUniqueKeysCacheBase> {
+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;
@@ -401,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[];
 }