@splitsoftware/splitio-commons 1.6.2-rc.12 → 1.6.2-rc.14

package/src/sync/submitters/types.ts

@@ -76,6 +76,8 @@ export type StoredImpressionWithMetadata = {
     c: number,
     /** time */
     m: number
+    /** previous time */
+    pt?: number
   }
 }
 
@@ -112,9 +114,9 @@ export type SEGMENT = 'se';
 export type MY_SEGMENT = 'ms';
 export type OperationType = SPLITS | IMPRESSIONS | IMPRESSIONS_COUNT | EVENTS | TELEMETRY | TOKEN | SEGMENT | MY_SEGMENT;
 
-export type LastSync = Record<OperationType, number | undefined>
-export type HttpErrors = Record<OperationType, { [statusCode: string]: number }>
-export type HttpLatencies = Record<OperationType, Array<number>>
+export type LastSync = Partial<Record<OperationType, number | undefined>>
+export type HttpErrors = Partial<Record<OperationType, { [statusCode: string]: number }>>
+export type HttpLatencies = Partial<Record<OperationType, Array<number>>>
 
 export type TREATMENT = 't';
 export type TREATMENTS = 'ts';
@@ -123,9 +125,9 @@ export type TREATMENTS_WITH_CONFIG = 'tcs';
 export type TRACK = 'tr';
 export type Method = TREATMENT | TREATMENTS | TREATMENT_WITH_CONFIG | TREATMENTS_WITH_CONFIG | TRACK;
 
-export type MethodLatencies = Record<Method, Array<number>>;
+export type MethodLatencies = Partial<Record<Method, Array<number>>>;
 
-export type MethodExceptions = Record<Method, number>;
+export type MethodExceptions = Partial<Record<Method, number>>;
 
 export type CONNECTION_ESTABLISHED = 0;
 export type OCCUPANCY_PRI = 10;

package/src/trackers/impressionObserver/utils.ts

@@ -1,21 +1,6 @@
-import { CONSUMER_MODE, CONSUMER_PARTIAL_MODE, OPTIMIZED, PRODUCER_MODE, STANDALONE_MODE } from '../../utils/constants';
+import { CONSUMER_MODE, CONSUMER_PARTIAL_MODE } from '../../utils/constants';
 import { ISettings } from '../../types';
 
-/**
- * Checks if impressions previous time should be added or not.
- */
-export function shouldAddPt(settings: ISettings) {
-  return [PRODUCER_MODE, STANDALONE_MODE, CONSUMER_PARTIAL_MODE].indexOf(settings.mode) > -1 ? true : false;
-}
-
-/**
- * Checks if it should dedupe impressions or not.
- */
-export function shouldBeOptimized(settings: ISettings) {
-  if (!shouldAddPt(settings)) return false;
-  return settings.sync.impressionsMode === OPTIMIZED ? true : false;
-}
-
 /**
  * Storage is async if mode is consumer or partial consumer
  */

package/src/trackers/impressionsTracker.ts

@@ -31,9 +31,9 @@ export function impressionsTrackerFactory(
 
       const impressionsCount = impressions.length;
       const { impressionsToStore, impressionsToListener, deduped } = strategy.process(impressions);
-      
+
       const impressionsToListenerCount = impressionsToListener.length;
-      
+
       if ( impressionsToStore.length>0 ){
         const res = impressionsCache.track(impressionsToStore);
 

package/src/trackers/strategy/strategyDebug.ts

@@ -4,14 +4,14 @@ 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 function strategyDebugFactory(
   impressionsObserver: IImpressionObserver
 ): IStrategy {
-  
+
   return {
     process(impressions: ImpressionDTO[]) {
       impressions.forEach((impression) => {
@@ -19,8 +19,8 @@ export function strategyDebugFactory(
         impression.pt = impressionsObserver.testAndSet(impression);
       });
       return {
-        impressionsToStore: impressions, 
-        impressionsToListener: impressions, 
+        impressionsToStore: impressions,
+        impressionsToListener: impressions,
         deduped: 0
       };
     }

package/src/trackers/strategy/strategyNone.ts

@@ -1,32 +1,32 @@
-import { IImpressionCountsCacheSync } from '../../storages/types';
+import { IImpressionCountsCacheBase } from '../../storages/types';
 import { ImpressionDTO } from '../../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. 
+ * @param uniqueKeysTracker unique keys tracker in charge of tracking the unique keys per split.
  * @returns IStrategyResult
  */
 export function strategyNoneFactory(
-  impressionsCounter: IImpressionCountsCacheSync,
+  impressionsCounter: IImpressionCountsCacheBase,
   uniqueKeysTracker: IUniqueKeysTracker
 ): IStrategy {
-  
+
   return {
     process(impressions: ImpressionDTO[]) {
-      impressions.forEach((impression) => {        
+      impressions.forEach((impression) => {
         const now = Date.now();
         // Increments impression counter per featureName
         impressionsCounter.track(impression.feature, now, 1);
         // Keep track by unique key
         uniqueKeysTracker.track(impression.keyName, impression.feature);
       });
-      
+
       return {
-        impressionsToStore: [], 
-        impressionsToListener: impressions, 
+        impressionsToStore: [],
+        impressionsToListener: impressions,
         deduped: 0
       };
     }

package/src/trackers/strategy/strategyOptimized.ts

@@ -1,4 +1,4 @@
-import { IImpressionCountsCacheSync } from '../../storages/types';
+import { IImpressionCountsCacheBase } from '../../storages/types';
 import { ImpressionDTO } from '../../types';
 import { truncateTimeFrame } from '../../utils/time';
 import { IImpressionObserver } from '../impressionObserver/types';
@@ -6,35 +6,35 @@ 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 function strategyOptimizedFactory(
   impressionsObserver: IImpressionObserver,
-  impressionsCounter: IImpressionCountsCacheSync,
+  impressionsCounter: IImpressionCountsCacheBase,
 ): IStrategy {
-  
+
   return {
     process(impressions: ImpressionDTO[]) {
       const impressionsToStore: ImpressionDTO[] = [];
       impressions.forEach((impression) => {
         impression.pt = impressionsObserver.testAndSet(impression);
-        
+
         const now = Date.now();
-        
+
         // Increments impression counter per featureName
         if (impression.pt) impressionsCounter.track(impression.feature, now, 1);
-  
+
         // Checks if the impression should be added in queue to be sent
         if (!impression.pt || impression.pt < truncateTimeFrame(now)) {
           impressionsToStore.push(impression);
         }
       });
       return {
-        impressionsToStore: impressionsToStore, 
-        impressionsToListener: impressions, 
+        impressionsToStore: impressionsToStore,
+        impressionsToListener: impressions,
         deduped: impressions.length - impressionsToStore.length
       };
     }

package/src/trackers/uniqueKeysTracker.ts

@@ -4,16 +4,16 @@ import { IUniqueKeysCacheBase } from '../storages/types';
 import { IFilterAdapter, IUniqueKeysTracker } from './types';
 
 const noopFilterAdapter = {
-  add() {return true;},
-  contains() {return true;},
-  clear() {}
+  add() { return true; },
+  contains() { return true; },
+  clear() { }
 };
 
 /**
  * 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
  * @param filterAdapter filter adapter
@@ -42,7 +42,7 @@ export function uniqueKeysTrackerFactory(
     stop(): void {
       clearInterval(intervalId);
     }
-    
+
   };
 
 }

package/src/utils/redis/RedisMock.ts

@@ -12,9 +12,9 @@ const ASYNC_METHODS = ['rpush', 'hincrby'];
 const PIPELINE_METHODS = ['rpush', 'hincrby'];
 
 export class RedisMock {
-  
+
   private pipelineMethods: any = { exec: jest.fn(asyncFunction) }
-  
+
   constructor() {
     IDENTITY_METHODS.forEach(method => {
       this[method] = jest.fn(identityFunction);
@@ -25,9 +25,9 @@ export class RedisMock {
     PIPELINE_METHODS.forEach(method => {
       this.pipelineMethods[method] = this[method];
     });
-    
+
     this.pipeline = jest.fn(() => {return this.pipelineMethods;});
   }
-  
-  
+
+
 }

package/src/utils/settingsValidation/index.ts

@@ -154,8 +154,8 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   if (storage) withDefaults.storage = storage(withDefaults);
 
   // Validate key and TT (for client-side)
+  const maybeKey = withDefaults.core.key;
   if (validationParams.acceptKey) {
-    const maybeKey = withDefaults.core.key;
     // Although `key` is required in client-side, it can be omitted in LOCALHOST mode. In that case, the value `localhost_key` is used.
     if (withDefaults.mode === LOCALHOST_MODE && maybeKey === undefined) {
       withDefaults.core.key = 'localhost_key';
@@ -172,6 +172,10 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
         withDefaults.core.trafficType = validateTrafficType(log, maybeTT, 'Client instantiation');
       }
     }
+  } else {
+    // On server-side, key is undefined and used to distinguish from client-side
+    if (maybeKey !== undefined) log.warn('Provided `key` is ignored in server-side SDK.'); // @ts-ignore
+    withDefaults.core.key = undefined;
   }
 
   // Current ip/hostname information

package/types/storages/KeyBuilderSS.d.ts

@@ -1,6 +1,7 @@
 import { KeyBuilder } from './KeyBuilder';
 import { IMetadata } from '../dtos/types';
 import { Method } from '../sync/submitters/types';
+export declare const METHOD_NAMES: Record<Method, string>;
 export declare class KeyBuilderSS extends KeyBuilder {
     latencyPrefix: string;
     exceptionPrefix: string;
@@ -17,6 +18,3 @@ export declare class KeyBuilderSS extends KeyBuilder {
     buildExceptionKey(method: Method): string;
     buildInitKey(): 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/storages/inMemory/TelemetryCacheInMemory.d.ts

@@ -1,13 +1,21 @@
-import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies, StreamingEvent, Method, OperationType, MethodExceptions, MethodLatencies } from '../../sync/submitters/types';
-import { IStorageFactoryParams, ITelemetryCacheSync } from '../types';
+import { ImpressionDataType, EventDataType, StreamingEvent, Method, OperationType, TelemetryUsageStatsPayload } from '../../sync/submitters/types';
+import { ISegmentsCacheSync, ISplitsCacheSync, IStorageFactoryParams, ITelemetryCacheSync } from '../types';
 export declare const MAX_LATENCY_BUCKET_COUNT = 23;
 export declare function newBuckets(): number[];
 /**
  * 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(params: IStorageFactoryParams): boolean;
+export declare function shouldRecordTelemetry({ settings }: IStorageFactoryParams): boolean;
 export declare class TelemetryCacheInMemory implements ITelemetryCacheSync {
+    private splits?;
+    private segments?;
+    constructor(splits?: ISplitsCacheSync | undefined, segments?: ISegmentsCacheSync | undefined);
+    private e;
+    isEmpty(): boolean;
+    clear(): void;
+    pop(): TelemetryUsageStatsPayload;
+    /** Config stats */
     private timeUntilReady?;
     getTimeUntilReady(): number | undefined;
     recordTimeUntilReady(ms: number): void;
@@ -17,6 +25,7 @@ export declare class TelemetryCacheInMemory implements ITelemetryCacheSync {
     private notReadyUsage;
     getNonReadyUsage(): number;
     recordNonReadyUsage(): void;
+    /** Usage stats */
     private impressionStats;
     getImpressionStats(type: ImpressionDataType): number;
     recordImpressionStats(type: ImpressionDataType, count: number): void;
@@ -24,13 +33,15 @@ export declare class TelemetryCacheInMemory implements ITelemetryCacheSync {
     getEventStats(type: EventDataType): number;
     recordEventStats(type: EventDataType, count: number): void;
     private lastSync;
-    getLastSynchronization(): LastSync;
+    getLastSynchronization(): Partial<Record<OperationType, number | undefined>>;
     recordSuccessfulSync(resource: OperationType, timeMs: number): void;
     private httpErrors;
-    popHttpErrors(): HttpErrors;
+    popHttpErrors(): Partial<Record<OperationType, {
+        [statusCode: string]: number;
+    }>>;
     recordHttpError(resource: OperationType, status: number): void;
     private httpLatencies;
-    popHttpLatencies(): HttpLatencies;
+    popHttpLatencies(): Partial<Record<OperationType, number[]>>;
     recordHttpLatency(resource: OperationType, latencyMs: number): void;
     private authRejections;
     popAuthRejections(): number;
@@ -48,9 +59,9 @@ export declare class TelemetryCacheInMemory implements ITelemetryCacheSync {
     getSessionLength(): number | undefined;
     recordSessionLength(ms: number): void;
     private exceptions;
-    popExceptions(): MethodExceptions;
+    popExceptions(): Partial<Record<Method, number>>;
     recordException(method: Method): void;
     private latencies;
-    popLatencies(): MethodLatencies;
+    popLatencies(): Partial<Record<Method, number[]>>;
     recordLatency(method: Method, latencyMs: number): void;
 }

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/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/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, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, 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,21 +64,21 @@ export interface IPluggableStorageWrapper {
     getMany: (keys: string[]) => Promise<(string | null)[]>;
     /** Integer operations */
     /**
-     * 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.
+     * 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
+     * @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, increment?: number) => Promise<number>;
     /**
-     * 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.
+     * 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
+     * @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.
      */
@@ -264,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.
@@ -356,7 +350,7 @@ 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.
@@ -377,7 +371,7 @@ export interface ITelemetryCacheAsync extends ITelemetryEvaluationProducerAsync,
 /**
  * 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;
@@ -388,23 +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 | ITelemetryCacheSync, 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;
-    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

@@ -69,6 +69,8 @@ export declare type StoredImpressionWithMetadata = {
         c: number;
         /** time */
         m: number;
+        /** previous time */
+        pt?: number;
     };
 };
 export declare type StoredEventWithMetadata = {
@@ -97,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;

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;