@splitsoftware/splitio-commons 1.6.2-rc.8 → 1.7.0

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

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

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

@@ -11,7 +11,6 @@ export declare class ImpressionsCacheInRedis implements IImpressionsCacheAsync {
     private readonly metadata;
     constructor(log: ILogger, key: string, redis: Redis, metadata: IMetadata);
     track(impressions: ImpressionDTO[]): Promise<void>;
-    private _toJSON;
     count(): Promise<number>;
     drop(count?: number): Promise<any>;
     popNWithMetadata(count: number): Promise<StoredImpressionWithMetadata[]>;

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/uniqueKeysCacheInRedis.d.ts

@@ -1,7 +1,8 @@
 import { IUniqueKeysCacheBase } from '../types';
 import { Redis } from 'ioredis';
-import { UniqueKeysCacheInMemory } from '../inMemory/uniqueKeysCacheInMemory';
+import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
 import { ILogger } from '../../logger/types';
+import { UniqueKeysItemSs } from '../../sync/submitters/types';
 export declare class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
     private readonly log;
     private readonly key;
@@ -9,7 +10,12 @@ export declare class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory impl
     private readonly refreshRate;
     private intervalId;
     constructor(log: ILogger, key: string, redis: Redis, uniqueKeysQueueSize?: number, refreshRate?: number);
-    postUniqueKeysInRedis(): Promise<boolean | import("ioredis").BooleanResponse | undefined>;
+    private postUniqueKeysInRedis;
     start(): void;
     stop(): Promise<boolean | import("ioredis").BooleanResponse | undefined>;
+    /**
+     * Async consumer API, used by synchronizer.
+     * @param count number of items to pop from the queue. If not provided or equal 0, all items will be popped.
+     */
+    popNRaw(count?: number): Promise<UniqueKeysItemSs[]>;
 }

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

@@ -0,0 +1,16 @@
+import { ILogger } from '../../logger/types';
+import { ImpressionCountsPayload } from '../../sync/submitters/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>;
+    getImpressionsCount(): Promise<ImpressionCountsPayload | undefined>;
+}

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

@@ -1,8 +1,8 @@
 import { IPluggableStorageWrapper, IImpressionsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
 import { ImpressionDTO } from '../../types';
-import { ILogger } from '../../logger/types';
 import { StoredImpressionWithMetadata } from '../../sync/submitters/types';
+import { ILogger } from '../../logger/types';
 export declare class ImpressionsCachePluggable implements IImpressionsCacheAsync {
     private readonly log;
     private readonly key;
@@ -16,7 +16,6 @@ export declare class ImpressionsCachePluggable implements IImpressionsCacheAsync
      * or rejected if the wrapper operation fails.
      */
     track(impressions: ImpressionDTO[]): Promise<void>;
-    private _toJSON;
     /**
      * Returns a promise that resolves with the count of stored impressions, or 0 if there was some error.
      * The promise will never be rejected.

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,20 @@
+import { IPluggableStorageWrapper, IUniqueKeysCacheBase } from '../types';
+import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
+import { ILogger } from '../../logger/types';
+import { UniqueKeysItemSs } from '../../sync/submitters/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>;
+    /**
+     * Async consumer API, used by synchronizer.
+     * @param count number of items to pop from the queue. If not provided or equal 0, all items will be popped.
+     */
+    popNRaw(count?: number): Promise<UniqueKeysItemSs[]>;
+}

package/types/storages/types.d.ts

@@ -1,7 +1,6 @@
-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, UniqueKeysPayloadCs, UniqueKeysPayloadSs } from '../sync/submitters/types';
-import { SplitIO, ImpressionDTO, SDKMode } from '../types';
+import { MaybeThenable, ISplit } from '../dtos/types';
+import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs, TelemetryUsageStatsPayload } from '../sync/submitters/types';
+import { SplitIO, ImpressionDTO, ISettings } from '../types';
 /**
  * Interface of a pluggable storage wrapper.
  */
@@ -65,23 +64,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 set it to `increment` if the value doesn't exist.
      *
      * @function incr
      * @param {string} key Key to increment
+     * @param {number} increment Value to increment by. Defaults to 1.
      * @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 set it to minus `decrement` if the value doesn't exist.
      *
      * @function decr
      * @param {string} key Key to decrement
+     * @param {number} decrement Value to decrement by. Defaults to 1.
      * @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.
@@ -262,48 +263,43 @@ export interface IImpressionsCacheBase {
 export interface IEventsCacheBase {
     track(data: SplitIO.EventData, size?: number): MaybeThenable<boolean>;
 }
-/** Impressions and events cache for standalone mode (sync) */
-export interface IRecorderCacheProducerSync<T> {
+export interface IImpressionCountsCacheBase {
+    track(featureName: string, timeFrame: number, amount: number): void;
+}
+export interface IUniqueKeysCacheBase {
+    track(key: string, value: string): void;
+}
+/** Impressions and events cache for standalone and partial consumer modes (sync methods) */
+export interface IRecorderCacheSync<T> {
     isEmpty(): boolean;
     clear(): void;
     pop(toMerge?: T): T;
 }
-export interface IImpressionsCacheSync extends IImpressionsCacheBase, IRecorderCacheProducerSync<ImpressionDTO[]> {
+export interface IImpressionsCacheSync extends IImpressionsCacheBase, IRecorderCacheSync<ImpressionDTO[]> {
     track(data: ImpressionDTO[]): void;
     setOnFullQueueCb(cb: () => void): void;
 }
-export interface IEventsCacheSync extends IEventsCacheBase, IRecorderCacheProducerSync<SplitIO.EventData[]> {
+export interface IEventsCacheSync extends IEventsCacheBase, IRecorderCacheSync<SplitIO.EventData[]> {
     track(data: SplitIO.EventData, size?: number): boolean;
     setOnFullQueueCb(cb: () => void): void;
 }
-/** Impressions and events cache for consumer and producer mode (async) */
-export interface IRecorderCacheProducerAsync<T> {
+export interface IImpressionCountsCacheSync extends IImpressionCountsCacheBase, IRecorderCacheSync<Record<string, number>> {
+}
+export interface IUniqueKeysCacheSync extends IUniqueKeysCacheBase, IRecorderCacheSync<UniqueKeysPayloadSs | UniqueKeysPayloadCs> {
+    setOnFullQueueCb(cb: () => void): void;
+}
+/** Impressions and events cache for consumer and producer modes (async methods) */
+export interface IRecorderCacheAsync<T> {
     count(): Promise<number>;
     drop(count?: number): Promise<void>;
     popNWithMetadata(count: number): Promise<T>;
 }
-export interface IImpressionsCacheAsync extends IImpressionsCacheBase, IRecorderCacheProducerAsync<StoredImpressionWithMetadata[]> {
+export interface IImpressionsCacheAsync extends IImpressionsCacheBase, IRecorderCacheAsync<StoredImpressionWithMetadata[]> {
     track(data: ImpressionDTO[]): Promise<void>;
 }
-export interface IEventsCacheAsync extends IEventsCacheBase, IRecorderCacheProducerAsync<StoredEventWithMetadata[]> {
+export interface IEventsCacheAsync extends IEventsCacheBase, IRecorderCacheAsync<StoredEventWithMetadata[]> {
     track(data: SplitIO.EventData, size?: number): Promise<boolean>;
 }
-/**
- * Impression counts cache for impressions dedup in standalone and producer mode.
- * Only in memory. Named `ImpressionsCounter` in spec.
- */
-export interface IImpressionCountsCacheSync extends IRecorderCacheProducerSync<Record<string, number>> {
-    track(featureName: string, timeFrame: number, amount: number): void;
-    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,26 +350,28 @@ export interface ITelemetryEvaluationProducerSync {
 }
 export interface ITelemetryStorageProducerSync extends ITelemetryInitProducerSync, ITelemetryRuntimeProducerSync, ITelemetryEvaluationProducerSync {
 }
-export interface ITelemetryCacheSync extends ITelemetryStorageConsumerSync, ITelemetryStorageProducerSync {
+export interface ITelemetryCacheSync extends ITelemetryStorageConsumerSync, ITelemetryStorageProducerSync, IRecorderCacheSync<TelemetryUsageStatsPayload> {
 }
 /**
  * Telemetry storage interface for consumer mode.
  * 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, TImpressionsCountCache extends IImpressionCountsCacheSync, TEventsCache extends IEventsCacheBase, TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync, TUniqueKeysCache extends IUniqueKeysCacheBase> {
+export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCache extends ISegmentsCacheBase, TImpressionsCache extends IImpressionsCacheBase, TImpressionsCountCache extends IImpressionCountsCacheBase, TEventsCache extends IEventsCacheBase, TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync, TUniqueKeysCache extends IUniqueKeysCacheBase> {
     splits: TSplitsCache;
     segments: TSegmentsCache;
     impressions: TImpressionsCache;
@@ -384,24 +382,19 @@ export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCa
     destroy(): void | Promise<void>;
     shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this;
 }
-export interface IStorageSync extends IStorageBase<ISplitsCacheSync, ISegmentsCacheSync, IImpressionsCacheSync, IImpressionCountsCacheSync, IEventsCacheSync, ITelemetryCacheSync, IUniqueKeysCacheBase> {
+export interface IStorageSync extends IStorageBase<ISplitsCacheSync, ISegmentsCacheSync, IImpressionsCacheSync, IImpressionCountsCacheSync, IEventsCacheSync, ITelemetryCacheSync, IUniqueKeysCacheSync> {
 }
-export interface IStorageAsync extends IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync | IImpressionsCacheSync, IImpressionCountsCacheSync, IEventsCacheAsync | IEventsCacheSync, ITelemetryCacheAsync, IUniqueKeysCacheBase> {
+export interface IStorageAsync extends IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync | IImpressionsCacheSync, IImpressionCountsCacheBase, IEventsCacheAsync | IEventsCacheSync, ITelemetryCacheAsync | ITelemetryCacheSync, IUniqueKeysCacheBase> {
 }
 /** StorageFactory */
 export declare type DataLoader = (storage: IStorageSync, matchingKey: string) => void;
 export interface IStorageFactoryParams {
-    log: ILogger;
-    impressionsQueueSize?: number;
-    uniqueKeysCacheSize?: number;
-    eventsQueueSize?: number;
-    optimize?: boolean;
-    mode: SDKMode;
-    impressionsMode?: string;
-    matchingKey?: string;
-    splitFiltersValidation?: ISplitFiltersValidation;
+    settings: ISettings;
+    /**
+     * Error-first callback invoked when the storage is ready to be used. An error means that the storage failed to connect and shouldn't be used.
+     * It is meant for emitting SDK_READY event in consumer mode, and waiting before using the storage in the synchronizer.
+     */
     onReadyCb: (error?: any) => void;
-    metadata: IMetadata;
 }
 export declare type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';
 export declare type IStorageSyncFactory = {

package/types/storages/utils.d.ts

@@ -0,0 +1,8 @@
+import { IMetadata } from '../dtos/types';
+import { Method } from '../sync/submitters/types';
+import { ImpressionDTO, ISettings } from '../types';
+export declare function metadataBuilder(settings: Pick<ISettings, 'version' | 'runtime'>): IMetadata;
+export declare function impressionsToJSON(impressions: ImpressionDTO[], metadata: IMetadata): string[];
+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/sync/submitters/submitter.d.ts

@@ -1,11 +1,11 @@
 import { ISyncTask } from '../types';
-import { IRecorderCacheProducerSync } from '../../storages/types';
+import { IRecorderCacheSync } from '../../storages/types';
 import { ILogger } from '../../logger/types';
 import { IResponse } from '../../services/types';
 /**
  * Base function to create submitters, such as ImpressionsSubmitter and EventsSubmitter
  */
-export declare function submitterFactory<T>(log: ILogger, postClient: (body: string) => Promise<IResponse>, sourceCache: IRecorderCacheProducerSync<T>, postRate: number, dataName: string, fromCacheToPayload?: (cacheData: T) => any, maxRetries?: number, debugLogs?: boolean): ISyncTask<[], void>;
+export declare function submitterFactory<T>(log: ILogger, postClient: (body: string) => Promise<IResponse>, sourceCache: IRecorderCacheSync<T>, postRate: number, dataName: string, fromCacheToPayload?: (cacheData: T) => any, maxRetries?: number, debugLogs?: boolean): ISyncTask<[], void>;
 /**
  * Decorates a provided submitter with a first execution window
  */

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

@@ -1,15 +1,7 @@
-import { ISegmentsCacheSync, ISplitsCacheSync, ITelemetryCacheSync } from '../../storages/types';
-import { TelemetryUsageStatsPayload, TelemetryConfigStatsPayload, TelemetryConfigStats } from './types';
+import { ITelemetryCacheSync } from '../../storages/types';
+import { TelemetryConfigStatsPayload, TelemetryConfigStats } from './types';
 import { ISettings, SDKMode } from '../../types';
 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): {
-    isEmpty(): boolean;
-    clear(): void;
-    pop(): TelemetryUsageStatsPayload;
-};
 export declare function getTelemetryConfigStats(mode: SDKMode, storageType: string): TelemetryConfigStats;
 /**
  * Converts data from telemetry cache and settings into /metrics/config request payload.

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,13 +33,14 @@ export declare type ImpressionCountsPayload = {
         rc: number;
     }[];
 };
+export declare type UniqueKeysItemSs = {
+    /** Split name */
+    f: string;
+    /** keyNames */
+    ks: string[];
+};
 export declare type UniqueKeysPayloadSs = {
-    keys: {
-        /** Split name */
-        f: string;
-        /** keyNames */
-        ks: string[];
-    }[];
+    keys: UniqueKeysItemSs[];
 };
 export declare type UniqueKeysPayloadCs = {
     keys: {
@@ -67,6 +69,8 @@ export declare type StoredImpressionWithMetadata = {
         c: number;
         /** time */
         m: number;
+        /** previous time */
+        pt?: number;
     };
 };
 export declare type StoredEventWithMetadata = {
@@ -75,6 +79,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
  */
@@ -92,19 +99,19 @@ export declare type TOKEN = 'to';
 export declare type SEGMENT = 'se';
 export declare type MY_SEGMENT = 'ms';
 export declare type OperationType = SPLITS | IMPRESSIONS | IMPRESSIONS_COUNT | EVENTS | TELEMETRY | TOKEN | SEGMENT | MY_SEGMENT;
-export declare type LastSync = Record<OperationType, number | undefined>;
-export declare type HttpErrors = Record<OperationType, {
+export declare type LastSync = Partial<Record<OperationType, number | undefined>>;
+export declare type HttpErrors = Partial<Record<OperationType, {
     [statusCode: string]: number;
-}>;
-export declare type HttpLatencies = Record<OperationType, Array<number>>;
+}>>;
+export declare type HttpLatencies = Partial<Record<OperationType, Array<number>>>;
 export declare type TREATMENT = 't';
 export declare type TREATMENTS = 'ts';
 export declare type TREATMENT_WITH_CONFIG = 'tc';
 export declare type TREATMENTS_WITH_CONFIG = 'tcs';
 export declare type TRACK = 'tr';
 export declare type Method = TREATMENT | TREATMENTS | TREATMENT_WITH_CONFIG | TREATMENTS_WITH_CONFIG | TRACK;
-export declare type MethodLatencies = Record<Method, Array<number>>;
-export declare type MethodExceptions = Record<Method, number>;
+export declare type MethodLatencies = Partial<Record<Method, Array<number>>>;
+export declare type MethodExceptions = Partial<Record<Method, number>>;
 export declare type CONNECTION_ESTABLISHED = 0;
 export declare type OCCUPANCY_PRI = 10;
 export declare type OCCUPANCY_SEC = 20;
@@ -119,10 +126,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;
@@ -130,9 +139,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;

package/types/trackers/impressionObserver/utils.d.ts

@@ -1,12 +1,4 @@
 import { ISettings } from '../../types';
-/**
- * Checks if impressions previous time should be added or not.
- */
-export declare function shouldAddPt(settings: ISettings): boolean;
-/**
- * Checks if it should dedupe impressions or not.
- */
-export declare function shouldBeOptimized(settings: ISettings): boolean;
 /**
  * Storage is async if mode is consumer or partial consumer
  */

package/types/trackers/strategy/strategyNone.d.ts

@@ -1,4 +1,4 @@
-import { IImpressionCountsCacheSync } from '../../storages/types';
+import { IImpressionCountsCacheBase } from '../../storages/types';
 import { IStrategy, IUniqueKeysTracker } from '../types';
 /**
  * None strategy for impressions tracker.
@@ -7,4 +7,4 @@ import { IStrategy, IUniqueKeysTracker } from '../types';
  * @param uniqueKeysTracker unique keys tracker in charge of tracking the unique keys per split.
  * @returns IStrategyResult
  */
-export declare function strategyNoneFactory(impressionsCounter: IImpressionCountsCacheSync, uniqueKeysTracker: IUniqueKeysTracker): IStrategy;
+export declare function strategyNoneFactory(impressionsCounter: IImpressionCountsCacheBase, uniqueKeysTracker: IUniqueKeysTracker): IStrategy;

package/types/trackers/strategy/strategyOptimized.d.ts

@@ -1,4 +1,4 @@
-import { IImpressionCountsCacheSync } from '../../storages/types';
+import { IImpressionCountsCacheBase } from '../../storages/types';
 import { IImpressionObserver } from '../impressionObserver/types';
 import { IStrategy } from '../types';
 /**
@@ -8,4 +8,4 @@ import { IStrategy } from '../types';
  * @param impressionsCounter cache to save impressions count. impressions will be deduped (OPTIMIZED mode)
  * @returns IStrategyResult
  */
-export declare function strategyOptimizedFactory(impressionsObserver: IImpressionObserver, impressionsCounter: IImpressionCountsCacheSync): IStrategy;
+export declare function strategyOptimizedFactory(impressionsObserver: IImpressionObserver, impressionsCounter: IImpressionCountsCacheBase): IStrategy;

package/types/trackers/uniqueKeysTracker.d.ts

@@ -4,7 +4,7 @@ import { IFilterAdapter, IUniqueKeysTracker } from './types';
 /**
  * Trackes 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.
+ * 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

package/types/types.d.ts

@@ -74,8 +74,6 @@ export interface ISettings {
         featuresRefreshRate: number;
         impressionsRefreshRate: number;
         impressionsQueueSize: number;
-        uniqueKeysRefreshRate: number;
-        uniqueKeysCacheSize: number;
         /**
          * @deprecated
          */

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();
+}

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

@@ -14,7 +14,6 @@ export declare const base: {
         segmentsRefreshRate: number;
         telemetryRefreshRate: number;
         impressionsRefreshRate: number;
-        uniqueKeysRefreshRate: number;
         offlineRefreshRate: number;
         eventsPushRate: number;
         eventsQueueSize: number;

package/cjs/storages/metadataBuilder.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.metadataBuilder = void 0;
-var constants_1 = require("../utils/constants");
-function metadataBuilder(settings) {
-    return {
-        s: settings.version,
-        i: settings.runtime.ip || constants_1.UNKNOWN,
-        n: settings.runtime.hostname || constants_1.UNKNOWN,
-    };
-}
-exports.metadataBuilder = metadataBuilder;

package/esm/storages/metadataBuilder.js

@@ -1,8 +0,0 @@
-import { UNKNOWN } from '../utils/constants';
-export function metadataBuilder(settings) {
-    return {
-        s: settings.version,
-        i: settings.runtime.ip || UNKNOWN,
-        n: settings.runtime.hostname || UNKNOWN,
-    };
-}

package/src/storages/metadataBuilder.ts

@@ -1,11 +0,0 @@
-import { IMetadata } from '../dtos/types';
-import { ISettings } from '../types';
-import { UNKNOWN } from '../utils/constants';
-
-export function metadataBuilder(settings: Pick<ISettings, 'version' | 'runtime'>): IMetadata {
-  return {
-    s: settings.version,
-    i: settings.runtime.ip || UNKNOWN,
-    n: settings.runtime.hostname || UNKNOWN,
-  };
-}