@splitsoftware/splitio-commons 1.6.2-rc.6 → 1.6.2-rc.7

package/types/sdkClient/types.d.ts

@@ -0,0 +1,18 @@
+import { ISignalListener } from '../listeners/types';
+import { ISdkReadinessManager } from '../readiness/types';
+import { IStorageAsync, IStorageSync } from '../storages/types';
+import { ISyncManager } from '../sync/types';
+import { IEventTracker, IImpressionsTracker } from '../trackers/types';
+import { ISettings } from '../types';
+export interface IClientFactoryParams {
+    storage: IStorageSync | IStorageAsync;
+    sdkReadinessManager: ISdkReadinessManager;
+    settings: ISettings;
+    impressionsTracker: IImpressionsTracker;
+    eventTracker: IEventTracker;
+}
+export interface ISdkClientFactoryParams extends IClientFactoryParams {
+    signalListener?: ISignalListener;
+    syncManager?: ISyncManager;
+    sharedClient?: boolean;
+}

package/types/sdkFactory/types.d.ts

@@ -6,7 +6,7 @@ import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
 import { IStorageAsync, IStorageSync, ISplitsCacheSync, ISplitsCacheAsync, IStorageFactoryParams } from '../storages/types';
 import { ISyncManager } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
-import { IImpressionsTracker, IEventTracker, ITelemetryTracker } from '../trackers/types';
+import { IImpressionsTracker, IEventTracker, ITelemetryTracker, IFilterAdapter, IUniqueKeysTracker } from '../trackers/types';
 import { SplitIO, ISettings, IEventEmitter } from '../types';
 /**
  * Environment related dependencies.
@@ -42,6 +42,7 @@ export interface ISdkFactoryContext {
     eventTracker: IEventTracker;
     telemetryTracker: ITelemetryTracker;
     storage: IStorageSync | IStorageAsync;
+    uniqueKeysTracker?: IUniqueKeysTracker;
     signalListener?: ISignalListener;
     splitApi?: ISplitApi;
     syncManager?: ISyncManager;
@@ -70,11 +71,12 @@ export interface ISdkFactoryParams {
         (): SplitIO.ICsClient;
         (key: SplitIO.SplitKey, trafficType?: string | undefined): SplitIO.ICsClient;
     } | (() => SplitIO.IClient) | (() => SplitIO.IAsyncClient));
+    impressionsObserverFactory: () => IImpressionObserver;
+    filterAdapterFactory?: () => IFilterAdapter;
     SignalListener?: new (syncManager: ISyncManager | undefined, // Used by NodeSignalListener to flush data, and by BrowserSignalListener to close streaming connection.
     settings: ISettings, // Used by BrowserSignalListener
     storage: IStorageSync | IStorageAsync, // Used by BrowserSignalListener
     serviceApi: ISplitApi | undefined) => ISignalListener;
     integrationsManagerFactory?: (params: IIntegrationFactoryParams) => IIntegrationManager | undefined;
-    impressionsObserverFactory?: () => IImpressionObserver;
     extraProps?: (params: ISdkFactoryContext) => object;
 }

package/types/services/types.d.ts

@@ -20,6 +20,8 @@ export declare type IFetchSplitChanges = (since: number, noCache?: boolean, till
 export declare type IFetchSegmentChanges = (since: number, segmentName: string, noCache?: boolean, till?: number) => Promise<IResponse>;
 export declare type IFetchMySegments = (userMatchingKey: string, noCache?: boolean) => Promise<IResponse>;
 export declare type IPostEventsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
+export declare type IPostUniqueKeysBulkCs = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
+export declare type IPostUniqueKeysBulkSs = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
 export declare type IPostTestImpressionsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
 export declare type IPostTestImpressionsCount = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
 export declare type IPostMetricsConfig = (body: string) => Promise<IResponse>;
@@ -32,6 +34,8 @@ export interface ISplitApi {
     fetchSegmentChanges: IFetchSegmentChanges;
     fetchMySegments: IFetchMySegments;
     postEventsBulk: IPostEventsBulk;
+    postUniqueKeysBulkCs: IPostUniqueKeysBulkCs;
+    postUniqueKeysBulkSs: IPostUniqueKeysBulkSs;
     postTestImpressionsBulk: IPostTestImpressionsBulk;
     postTestImpressionsCount: IPostTestImpressionsCount;
     postMetricsConfig: IPostMetricsConfig;

package/types/storages/KeyBuilderSS.d.ts

@@ -6,6 +6,8 @@ export declare class KeyBuilderSS extends KeyBuilder {
     constructor(prefix: string, metadata: IMetadata);
     buildRegisteredSegmentsKey(): string;
     buildImpressionsKey(): string;
+    buildImpressionsCountKey(): string;
+    buildUniqueKeysKey(): string;
     buildEventsKey(): string;
     searchPatternForSplitKeys(): string;
     buildLatencyKey(method: Method, bucket: number): string;

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

@@ -0,0 +1,20 @@
+import { ICountsCacheSync } from '../types';
+export declare class CountsCacheInMemory implements ICountsCacheSync {
+    private counters;
+    /**
+     * Add counts.
+     */
+    track(metricName: string): boolean;
+    /**
+     * Clear the collector
+     */
+    clear(): void;
+    /**
+     * Get the collected data, used as payload for posting.
+     */
+    state(): Record<string, number>;
+    /**
+     * Check if the cache is empty.
+     */
+    isEmpty(): boolean;
+}

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

@@ -0,0 +1,20 @@
+import { ILatenciesCacheSync } from '../types';
+export declare class LatenciesCacheInMemory implements ILatenciesCacheSync {
+    private counters;
+    /**
+     * Add latencies.
+     */
+    track(metricName: string, latency: number): boolean;
+    /**
+     * Clear the collector
+     */
+    clear(): void;
+    /**
+     * Get the collected data, used as payload for posting.
+     */
+    state(): Record<string, number[]>;
+    /**
+     * Check if the cache is empty.
+     */
+    isEmpty(): boolean;
+}

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

@@ -0,0 +1,9 @@
+import { ICountsCacheAsync } from '../types';
+import { KeyBuilderSS } from '../KeyBuilderSS';
+import { Redis } from 'ioredis';
+export declare class CountsCacheInRedis implements ICountsCacheAsync {
+    private readonly redis;
+    private readonly keys;
+    constructor(keys: KeyBuilderSS, redis: Redis);
+    track(metricName: string): Promise<boolean>;
+}

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);
+    postImpressionCountsInRedis(): false | Promise<boolean | import("ioredis").BooleanResponse | undefined>;
+    start(): void;
+    stop(): void;
+}

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

@@ -0,0 +1,9 @@
+import { ILatenciesCacheAsync } from '../types';
+import { KeyBuilderSS } from '../KeyBuilderSS';
+import { Redis } from 'ioredis';
+export declare class LatenciesCacheInRedis implements ILatenciesCacheAsync {
+    private readonly redis;
+    private readonly keys;
+    constructor(keys: KeyBuilderSS, redis: Redis);
+    track(metricName: string, latency: number): Promise<boolean>;
+}

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);
+    postUniqueKeysInRedis(): Promise<boolean | import("ioredis").BooleanResponse | undefined>;
+    start(): void;
+    stop(): void;
+}

package/types/storages/types.d.ts

@@ -1,6 +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 } from '../sync/submitters/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';
 /**
  * Interface of a pluggable storage wrapper.
@@ -297,6 +297,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.
@@ -366,28 +373,34 @@ export interface ITelemetryCacheAsync extends ITelemetryEvaluationProducerAsync
 /**
  * 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, IUniqueKeysCacheBase> {
 }
 /** StorageFactory */
 export declare type DataLoader = (storage: IStorageSync, matchingKey: string) => void;
 export interface IStorageFactoryParams {
     log: ILogger;
     impressionsQueueSize?: number;
+    impressionCountsQueueSize?: number;
+    impressionCountsRefreshRate?: number;
+    uniqueKeysRefreshRate?: number;
+    uniqueKeysCacheSize?: number;
     eventsQueueSize?: number;
     optimize?: boolean;
     mode: SDKMode;
+    impressionsMode?: string;
     matchingKey?: string;
     splitFiltersValidation?: ISplitFiltersValidation;
     onReadyCb: (error?: any) => void;

package/types/sync/offline/LocalhostFromFile.d.ts

@@ -0,0 +1,2 @@
+import { SplitIO } from '../../types';
+export declare function LocalhostFromFile(): SplitIO.LocalhostFactory;

package/types/sync/offline/splitsParser/splitsParserFromFile.d.ts

@@ -0,0 +1,2 @@
+import { ISplitsParser } from './types';
+export declare function splitsParserFromFileFactory(): ISplitsParser;

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

@@ -0,0 +1,8 @@
+import { IEventsCacheSync } from '../../storages/types';
+import { IPostEventsBulk } from '../../services/types';
+import { ISyncTask, ITimeTracker } from '../types';
+import { ILogger } from '../../logger/types';
+/**
+ * Sync task that periodically posts tracked events
+ */
+export declare function eventsSyncTaskFactory(log: ILogger, postEventsBulk: IPostEventsBulk, eventsCache: IEventsCacheSync, eventsPushRate: number, eventsFirstPushWindow: number, latencyTracker?: ITimeTracker): ISyncTask;

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

@@ -0,0 +1,5 @@
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+/**
+ * Submitter that periodically posts impression counts
+ */
+export declare function impressionCountsSubmitterInRedisFactory(params: ISdkFactoryContextSync): import("../types").ISyncTask<[], void>;

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

@@ -0,0 +1,13 @@
+import { ISyncTask, ITimeTracker } from '../types';
+import { IPostTestImpressionsCount } from '../../services/types';
+import { IImpressionCountsCacheSync } from '../../storages/types';
+import { ImpressionCountsPayload } from './types';
+import { ILogger } from '../../logger/types';
+/**
+ * Converts `impressionCounts` data from cache into request payload.
+ */
+export declare function fromImpressionCountsCollector(impressionsCount: Record<string, number>): ImpressionCountsPayload;
+/**
+ * Sync task that periodically posts impression counts
+ */
+export declare function impressionCountsSyncTaskFactory(log: ILogger, postTestImpressionsCount: IPostTestImpressionsCount, impressionCountsCache: IImpressionCountsCacheSync, latencyTracker?: ITimeTracker): ISyncTask;

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

@@ -0,0 +1,14 @@
+import { ISyncTask, ITimeTracker } from '../types';
+import { IPostTestImpressionsBulk } from '../../services/types';
+import { IImpressionsCacheSync } from '../../storages/types';
+import { ImpressionDTO } from '../../types';
+import { ImpressionsPayload } from './types';
+import { ILogger } from '../../logger/types';
+/**
+ * Converts `impressions` data from cache into request payload.
+ */
+export declare function fromImpressionsCollector(sendLabels: boolean, data: ImpressionDTO[]): ImpressionsPayload;
+/**
+ * Sync task that periodically posts impressions data
+ */
+export declare function impressionsSyncTaskFactory(log: ILogger, postTestImpressionsBulk: IPostTestImpressionsBulk, impressionsCache: IImpressionsCacheSync, impressionsRefreshRate: number, sendLabels?: boolean, latencyTracker?: ITimeTracker): ISyncTask;

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

@@ -0,0 +1,12 @@
+import { ICountsCacheSync, ILatenciesCacheSync } from '../../storages/types';
+import { IPostMetricsCounters, IPostMetricsTimes } from '../../services/types';
+import { ISyncTask, ITimeTracker } from '../types';
+import { ILogger } from '../../logger/types';
+/**
+ * Sync task that periodically posts telemetry counts
+ */
+export declare function countsSyncTaskFactory(log: ILogger, postMetricsCounters: IPostMetricsCounters, countsCache: ICountsCacheSync, metricsRefreshRate: number, latencyTracker?: ITimeTracker): ISyncTask;
+/**
+ * Sync task that periodically posts telemetry latencies
+ */
+export declare function latenciesSyncTaskFactory(log: ILogger, postMetricsLatencies: IPostMetricsTimes, latenciesCache: ILatenciesCacheSync, metricsRefreshRate: number, latencyTracker?: ITimeTracker): ISyncTask;

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

@@ -0,0 +1,10 @@
+import { ISyncTask, ITimeTracker } from '../types';
+import { IRecorderCacheProducerSync } from '../../storages/types';
+import { ILogger } from '../../logger/types';
+import { IResponse } from '../../services/types';
+/**
+ * Base function to create submitter sync tasks, such as ImpressionsSyncTask and EventsSyncTask
+ */
+export declare function submitterSyncTaskFactory<TState extends {
+    length?: number;
+}>(log: ILogger, postClient: (body: string) => Promise<IResponse>, sourceCache: IRecorderCacheProducerSync<TState>, postRate: number, dataName: string, latencyTracker?: ITimeTracker, fromCacheToPayload?: (cacheData: TState) => any, maxRetries?: number, debugLogs?: boolean): ISyncTask<[], void>;

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

@@ -32,6 +32,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;
@@ -132,7 +148,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

@@ -0,0 +1,5 @@
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+/**
+ * Submitter that periodically posts impression counts
+ */
+export declare function uniqueKeysSubmitterFactory(params: ISdkFactoryContextSync): import("../types").ISyncTask<[], void>;

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

@@ -0,0 +1,5 @@
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+/**
+ * Submitter that periodically posts impression counts
+ */
+export declare function uniqueKeysSubmitterInRedisFactory(params: ISdkFactoryContextSync): import("../types").ISyncTask<[], void>;

package/types/sync/syncTaskComposite.d.ts

@@ -0,0 +1,5 @@
+import { ISyncTask } from './types';
+/**
+ * Composite Sync Task: group of sync tasks that are treated as a single one.
+ */
+export declare function syncTaskComposite(syncTasks: ISyncTask[]): ISyncTask;

package/types/trackers/filter/bloomFilter.d.ts

@@ -0,0 +1,10 @@
+import { IFilter } from './types';
+export declare class BloomFilterImp implements IFilter {
+    private spectedInsertions;
+    private errorRate;
+    private filter;
+    constructor(spectedInsertions: number, errorRate: number);
+    add(data: string): boolean;
+    contains(data: string): boolean;
+    clear(): void;
+}

package/types/trackers/filter/dictionaryFilter.d.ts

@@ -0,0 +1,8 @@
+import { IFilter } from './types';
+export declare class DictionaryFilter implements IFilter {
+    private filter;
+    constructor();
+    add(data: string): boolean;
+    contains(data: string): boolean;
+    clear(): void;
+}

package/types/trackers/filter/types.d.ts

@@ -0,0 +1,5 @@
+export interface IFilter {
+    add(data: string): boolean;
+    contains(data: string): boolean;
+    clear(): void;
+}

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

@@ -0,0 +1,9 @@
+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 IStrategyResult
+ */
+export declare function strategyDebugFactory(impressionsObserver: IImpressionObserver): IStrategy;

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

@@ -0,0 +1,10 @@
+import { IImpressionCountsCacheSync } from '../../storages/types';
+import { IStrategy, IUniqueKeysTracker } from '../types';
+/**
+ * None strategy for impressions tracker.
+ *
+ * @param impressionsCounter 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 IStrategyResult
+ */
+export declare function strategyNoneFactory(impressionsCounter: IImpressionCountsCacheSync, uniqueKeysTracker: IUniqueKeysTracker): IStrategy;

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

@@ -0,0 +1,11 @@
+import { IImpressionCountsCacheSync } from '../../storages/types';
+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 impressionsCounter cache to save impressions count. impressions will be deduped (OPTIMIZED mode)
+ * @returns IStrategyResult
+ */
+export declare function strategyOptimizedFactory(impressionsObserver: IImpressionObserver, impressionsCounter: IImpressionCountsCacheSync): IStrategy;

package/types/trackers/types.d.ts

@@ -38,3 +38,26 @@ export interface ITelemetryTracker {
      */
     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

@@ -0,0 +1,13 @@
+import { ILogger } from '../logger/types';
+import { IUniqueKeysCacheBase } from '../storages/types';
+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.
+ *
+ * @param log Logger instance
+ * @param uniqueKeysCache cache to save unique keys
+ * @param filterAdapter filter adapter
+ */
+export declare function uniqueKeysTrackerFactory(log: ILogger, uniqueKeysCache: IUniqueKeysCacheBase, filterAdapter?: IFilterAdapter): IUniqueKeysTracker;

package/types/types.d.ts

@@ -74,6 +74,10 @@ export interface ISettings {
         featuresRefreshRate: number;
         impressionsRefreshRate: number;
         impressionsQueueSize: number;
+        impressionCountsRefreshRate: number;
+        impressionCountsQueueSize: number;
+        uniqueKeysRefreshRate: number;
+        uniqueKeysCacheSize: number;
         /**
          * @deprecated
          */
@@ -715,7 +719,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";