@splitsoftware/splitio-commons 1.3.1 → 1.3.2-rc.0

package/types/storages/KeyBuilderSS.d.ts

@@ -1,5 +1,6 @@
 import { KeyBuilder } from './KeyBuilder';
 import { IMetadata } from '../dtos/types';
+import { Method } from '../sync/submitters/types';
 export declare class KeyBuilderSS extends KeyBuilder {
     protected readonly metadata: IMetadata;
     constructor(prefix: string, metadata: IMetadata);
@@ -7,8 +8,7 @@ export declare class KeyBuilderSS extends KeyBuilder {
     private buildVersionablePrefix;
     buildImpressionsKey(): string;
     buildEventsKey(): string;
-    private buildLatencyKeyPrefix;
-    buildLatencyKey(metricName: string, bucketNumber: number | string): string;
-    buildCountKey(metricName: string): string;
+    buildLatencyKey(method: Method, bucket: number): string;
+    buildExceptionKey(method: Method): string;
     searchPatternForSplitKeys(): string;
 }

package/types/storages/findLatencyIndex.d.ts

@@ -1 +1,7 @@
-export declare function findLatencyIndex(latency: number, min?: number, max?: number, base?: number): number;
+/**
+ * Calculates buckets from latency in milliseconds
+ *
+ * @param latencyInMs
+ * @returns a bucket index from 0 to 22 inclusive
+ */
+export declare function findLatencyIndex(latencyInMs: number): number;

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

@@ -20,4 +20,6 @@ export declare class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
      * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
      */
     resetSegments(names: string[]): boolean;
+    getRegisteredSegments(): string[];
+    getKeysCount(): number;
 }

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

@@ -17,4 +17,6 @@ export declare class MySegmentsCacheInMemory extends AbstractSegmentsCacheSync {
      * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
      */
     resetSegments(names: string[]): boolean;
+    getRegisteredSegments(): string[];
+    getKeysCount(): number;
 }

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

@@ -13,6 +13,7 @@ export declare class SegmentsCacheInMemory extends AbstractSegmentsCacheSync {
     private _registerSegment;
     registerSegments(names: string[]): boolean;
     getRegisteredSegments(): string[];
+    getKeysCount(): number;
     setChangeNumber(name: string, changeNumber: number): boolean;
     getChangeNumber(name: string): number;
 }

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

@@ -1,6 +1,10 @@
 import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies, StreamingEvent, Method, OperationType, MethodExceptions, MethodLatencies } from '../../sync/submitters/types';
-import { TelemetryCacheSync } from '../types';
-export declare class TelemetryCacheInMemory implements TelemetryCacheSync {
+import { ITelemetryCacheSync } from '../types';
+/**
+ * Used on client-side. 0.1% of instances will track telemetry
+ */
+export declare function shouldRecordTelemetry(): boolean;
+export declare class TelemetryCacheInMemory implements ITelemetryCacheSync {
     private timeUntilReady?;
     getTimeUntilReady(): number | undefined;
     recordTimeUntilReady(ms: number): void;

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

@@ -1,14 +1,14 @@
 import { ILogger } from '../../logger/types';
 import { Method } from '../../sync/submitters/types';
 import { KeyBuilderSS } from '../KeyBuilderSS';
-import { TelemetryCacheAsync } from '../types';
+import { ITelemetryCacheAsync } from '../types';
 import { Redis } from 'ioredis';
-export declare class TelemetryCacheInRedis implements TelemetryCacheAsync {
+export declare class TelemetryCacheInRedis implements ITelemetryCacheAsync {
     private readonly log;
     private readonly keys;
     private readonly redis;
     /**
-     * Create a Telemetry cache that uses a storage wrapper.
+     * Create a Telemetry cache that uses Redis as storage.
      * @param log  Logger instance.
      * @param keys  Key builder.
      * @param redis  Redis client.

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

@@ -1,8 +1,8 @@
 import { ILogger } from '../../logger/types';
 import { Method } from '../../sync/submitters/types';
 import { KeyBuilderSS } from '../KeyBuilderSS';
-import { IPluggableStorageWrapper, TelemetryCacheAsync } from '../types';
-export declare class TelemetryCachePluggable implements TelemetryCacheAsync {
+import { IPluggableStorageWrapper, ITelemetryCacheAsync } from '../types';
+export declare class TelemetryCachePluggable implements ITelemetryCacheAsync {
     private readonly log;
     private readonly keys;
     private readonly wrapper;

package/types/storages/types.d.ts

@@ -1,6 +1,6 @@
 import { MaybeThenable, IMetadata, ISplitFiltersValidation } from '../dtos/types';
 import { ILogger } from '../logger/types';
-import { StoredEventWithMetadata, StoredImpressionWithMetadata } from '../sync/submitters/types';
+import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent } from '../sync/submitters/types';
 import { SplitIO, ImpressionDTO, SDKMode } from '../types';
 /**
  * Interface of a pluggable storage wrapper.
@@ -239,6 +239,7 @@ export interface ISegmentsCacheSync extends ISegmentsCacheBase {
     isInSegment(name: string, key?: string): boolean;
     registerSegments(names: string[]): boolean;
     getRegisteredSegments(): string[];
+    getKeysCount(): number;
     setChangeNumber(name: string, changeNumber: number): boolean;
     getChangeNumber(name: string): number;
     resetSegments(names: string[]): boolean;
@@ -297,41 +298,89 @@ export interface IImpressionCountsCacheSync extends IRecorderCacheProducerSync<R
     clear(): void;
     state(): Record<string, number>;
 }
-/** Latencies and metric counts cache */
-export interface ILatenciesCacheSync extends IRecorderCacheProducerSync<Record<string, number[]>> {
-    track(metricName: string, latency: number): boolean;
-    isEmpty(): boolean;
-    clear(): void;
-    state(): Record<string, number[]>;
+/**
+ * Telemetry storage interface for standalone and partial consumer modes.
+ * Methods are sync because data is stored in memory.
+ */
+export interface ITelemetryInitConsumerSync {
+    getTimeUntilReady(): number | undefined;
+    getTimeUntilReadyFromCache(): number | undefined;
+    getNonReadyUsage(): number;
 }
-export interface ILatenciesCacheAsync {
-    track(metricName: string, latency: number): Promise<boolean>;
+export interface ITelemetryRuntimeConsumerSync {
+    getImpressionStats(type: ImpressionDataType): number;
+    getEventStats(type: EventDataType): number;
+    getLastSynchronization(): LastSync;
+    popHttpErrors(): HttpErrors;
+    popHttpLatencies(): HttpLatencies;
+    popAuthRejections(): number;
+    popTokenRefreshes(): number;
+    popStreamingEvents(): Array<StreamingEvent>;
+    popTags(): Array<string> | undefined;
+    getSessionLength(): number | undefined;
 }
-export interface ICountsCacheSync extends IRecorderCacheProducerSync<Record<string, number>> {
-    track(metricName: string): boolean;
-    isEmpty(): boolean;
-    clear(): void;
-    state(): Record<string, number>;
+export interface ITelemetryEvaluationConsumerSync {
+    popExceptions(): MethodExceptions;
+    popLatencies(): MethodLatencies;
+}
+export interface ITelemetryStorageConsumerSync extends ITelemetryInitConsumerSync, ITelemetryRuntimeConsumerSync, ITelemetryEvaluationConsumerSync {
+}
+export interface ITelemetryInitProducerSync {
+    recordTimeUntilReady(ms: number): void;
+    recordTimeUntilReadyFromCache(ms: number): void;
+    recordNonReadyUsage(): void;
+}
+export interface ITelemetryRuntimeProducerSync {
+    addTag(tag: string): void;
+    recordImpressionStats(type: ImpressionDataType, count: number): void;
+    recordEventStats(type: EventDataType, count: number): void;
+    recordSuccessfulSync(resource: OperationType, timeMs: number): void;
+    recordHttpError(resource: OperationType, status: number): void;
+    recordHttpLatency(resource: OperationType, latencyMs: number): void;
+    recordAuthRejections(): void;
+    recordTokenRefreshes(): void;
+    recordStreamingEvents(streamingEvent: StreamingEvent): void;
+    recordSessionLength(ms: number): void;
 }
-export interface ICountsCacheAsync {
-    track(metricName: string): Promise<boolean>;
+export interface ITelemetryEvaluationProducerSync {
+    recordLatency(method: Method, latencyMs: number): void;
+    recordException(method: Method): void;
+}
+export interface ITelemetryStorageProducerSync extends ITelemetryInitProducerSync, ITelemetryRuntimeProducerSync, ITelemetryEvaluationProducerSync {
+}
+export interface ITelemetryCacheSync extends ITelemetryStorageConsumerSync, ITelemetryStorageProducerSync {
+}
+/**
+ * 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>;
+}
+export interface ITelemetryEvaluationProducerAsync {
+    recordLatency(method: Method, latencyMs: number): Promise<any>;
+    recordException(method: Method): Promise<any>;
+}
+export interface ITelemetryCacheAsync extends ITelemetryEvaluationProducerAsync {
 }
 /**
  * Storages
  */
-export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCache extends ISegmentsCacheBase, TImpressionsCache extends IImpressionsCacheBase, TEventsCache extends IEventsCacheBase, TLatenciesCache extends ILatenciesCacheSync | ILatenciesCacheAsync, TCountsCache extends ICountsCacheSync | ICountsCacheAsync> {
+export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCache extends ISegmentsCacheBase, TImpressionsCache extends IImpressionsCacheBase, TEventsCache extends IEventsCacheBase, TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync> {
     splits: TSplitsCache;
     segments: TSegmentsCache;
     impressions: TImpressionsCache;
     impressionCounts?: IImpressionCountsCacheSync;
     events: TEventsCache;
-    latencies?: TLatenciesCache;
-    counts?: TCountsCache;
+    telemetry?: TTelemetryCache;
     destroy(): void | Promise<void>;
     shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this;
 }
-export declare type IStorageSync = IStorageBase<ISplitsCacheSync, ISegmentsCacheSync, IImpressionsCacheSync, IEventsCacheSync, ILatenciesCacheSync, ICountsCacheSync>;
-export declare type IStorageAsync = IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync | IImpressionsCacheSync, IEventsCacheAsync | IEventsCacheSync, ILatenciesCacheAsync, ICountsCacheAsync>;
+export interface IStorageSync extends IStorageBase<ISplitsCacheSync, ISegmentsCacheSync, IImpressionsCacheSync, IEventsCacheSync, ITelemetryCacheSync> {
+}
+export interface IStorageAsync extends IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync | IImpressionsCacheSync, IEventsCacheAsync | IEventsCacheSync, ITelemetryCacheAsync> {
+}
 /** StorageFactory */
 export declare type DataLoader = (storage: IStorageSync, matchingKey: string) => void;
 export interface IStorageFactoryParams {
@@ -339,9 +388,9 @@ export interface IStorageFactoryParams {
     impressionsQueueSize?: number;
     eventsQueueSize?: number;
     optimize?: boolean;
+    mode: SDKMode;
     matchingKey?: string;
     splitFiltersValidation?: ISplitFiltersValidation;
-    mode?: SDKMode;
     onReadyCb: (error?: any) => void;
     metadata: IMetadata;
 }

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

@@ -1,9 +1,10 @@
-import { ISyncManagerCS, ISyncManagerFactoryParams } from '../types';
+import { ISyncManagerCS } from '../types';
 import { ISplitsParser } from './splitsParser/types';
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 /**
  * Offline SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
  *
  * @param splitsParser e.g., `splitsParserFromFile`, `splitsParserFromSettings`.
  */
-export declare function syncManagerOfflineFactory(splitsParserFactory: () => ISplitsParser): (params: ISyncManagerFactoryParams) => ISyncManagerCS;
+export declare function syncManagerOfflineFactory(splitsParserFactory: () => ISplitsParser): (params: ISdkFactoryContextSync) => ISyncManagerCS;

package/types/sync/polling/pollingManagerCS.d.ts

@@ -1,7 +1,7 @@
 import { IPollingManagerCS } from './types';
-import { ISyncManagerFactoryParams } from '../types';
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 /**
  * Expose start / stop mechanism for polling data from services.
  * For client-side API with multiple clients.
  */
-export declare function pollingManagerCSFactory(params: ISyncManagerFactoryParams): IPollingManagerCS;
+export declare function pollingManagerCSFactory(params: ISdkFactoryContextSync): IPollingManagerCS;

package/types/sync/polling/pollingManagerSS.d.ts

@@ -1,6 +1,6 @@
 import { IPollingManager } from './types';
-import { ISyncManagerFactoryParams } from '../types';
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 /**
  * Expose start / stop mechanism for pulling data from services.
  */
-export declare function pollingManagerSSFactory(params: ISyncManagerFactoryParams): IPollingManager;
+export declare function pollingManagerSSFactory(params: ISdkFactoryContextSync): IPollingManager;

package/types/sync/streaming/SSEHandler/NotificationKeeper.d.ts

@@ -1,3 +1,4 @@
+import { ITelemetryTracker } from '../../../trackers/types';
 import { ControlType } from '../constants';
 import { IPushEventEmitter } from '../types';
 /**
@@ -5,7 +6,7 @@ import { IPushEventEmitter } from '../types';
  *
  * @param pushEmitter emitter for events related to streaming support
  */
-export declare function notificationKeeperFactory(pushEmitter: IPushEventEmitter): {
+export declare function notificationKeeperFactory(pushEmitter: IPushEventEmitter, telemetryTracker: ITelemetryTracker): {
     handleOpen(): void;
     isStreamingUp(): boolean;
     handleOccupancyEvent(publishers: number, channel: string, timestamp: number): void;

package/types/sync/streaming/SSEHandler/index.d.ts

@@ -1,10 +1,11 @@
 import { IPushEventEmitter } from '../types';
 import { ISseEventHandler } from '../SSEClient/types';
 import { ILogger } from '../../../logger/types';
+import { ITelemetryTracker } from '../../../trackers/types';
 /**
  * Factory for SSEHandler, which processes SSEClient messages and emits the corresponding push events.
  *
  * @param log factory logger
  * @param pushEmitter emitter for events related to streaming support
  */
-export declare function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventEmitter): ISseEventHandler;
+export declare function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventEmitter, telemetryTracker: ITelemetryTracker): ISseEventHandler;

package/types/sync/streaming/pushManager.d.ts

@@ -1,9 +1,9 @@
 import { IPushManager } from './types';
 import { IPollingManager } from '../polling/types';
-import { ISyncManagerFactoryParams } from '../types';
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 /**
  * PushManager factory:
  * - for server-side if key is not provided in settings.
  * - for client-side, with support for multiple clients, if key is provided in settings
  */
-export declare function pushManagerFactory(params: ISyncManagerFactoryParams, pollingManager: IPollingManager): IPushManager | undefined;
+export declare function pushManagerFactory(params: ISdkFactoryContextSync, pollingManager: IPollingManager): IPushManager | undefined;

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

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

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

@@ -0,0 +1,10 @@
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+import { ImpressionCountsPayload } from './types';
+/**
+ * Converts `impressionCounts` data from cache into request payload.
+ */
+export declare function fromImpressionCountsCollector(impressionsCount: Record<string, number>): ImpressionCountsPayload;
+/**
+ * Submitter that periodically posts impression counts
+ */
+export declare function impressionCountsSubmitterFactory(params: ISdkFactoryContextSync): import("../types").ISyncTask<[], void> | undefined;

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

@@ -0,0 +1,11 @@
+import { ImpressionDTO } from '../../types';
+import { ImpressionsPayload } from './types';
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+/**
+ * Converts `impressions` data from cache into request payload.
+ */
+export declare function fromImpressionsCollector(sendLabels: boolean, data: ImpressionDTO[]): ImpressionsPayload;
+/**
+ * Submitter that periodically posts impressions data
+ */
+export declare function impressionsSubmitterFactory(params: ISdkFactoryContextSync): import("../types").ISyncTask<[], void>;

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

@@ -0,0 +1,12 @@
+import { ISyncTask } from '../types';
+import { IRecorderCacheProducerSync } 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<TState>(log: ILogger, postClient: (body: string) => Promise<IResponse>, sourceCache: IRecorderCacheProducerSync<TState>, postRate: number, dataName: string, fromCacheToPayload?: (cacheData: TState) => any, maxRetries?: number, debugLogs?: boolean): ISyncTask<[], void>;
+/**
+ * Decorates a provided submitter with a first execution window
+ */
+export declare function firstPushWindowDecorator(submitter: ISyncTask, firstPushWindow: number): ISyncTask<[], any>;

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

@@ -1,2 +1,2 @@
-import { ISyncManagerFactoryParams } from '../types';
-export declare function submitterManagerFactory(params: ISyncManagerFactoryParams): import("../types").ISyncTask<[], any>;
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+export declare function submitterManagerFactory(params: ISdkFactoryContextSync): import("../types").ISyncTask<[], any>;

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

@@ -0,0 +1,24 @@
+import { ISegmentsCacheSync, ISplitsCacheSync, ITelemetryCacheSync } from '../../storages/types';
+import { TelemetryUsageStatsPayload, TelemetryConfigStatsPayload } from './types';
+import { ISettings } 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;
+    state(): TelemetryUsageStatsPayload;
+};
+/**
+ * Converts data from telemetry cache and settings into /metrics/config request payload.
+ */
+export declare function telemetryCacheConfigAdapter(telemetry: ITelemetryCacheSync, settings: ISettings): {
+    isEmpty(): boolean;
+    clear(): void;
+    state(): TelemetryConfigStatsPayload;
+};
+/**
+ * Submitter that periodically posts telemetry data
+ */
+export declare function telemetrySubmitterFactory(params: ISdkFactoryContextSync): import("../types").ISyncTask<[], any> | undefined;

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

@@ -1,27 +0,0 @@
-import { ISyncTask, ITimeTracker } from '../types';
-import { ISplitApi } from '../../services/types';
-import { IStorageSync, TelemetryCacheSync } from '../../storages/types';
-import { TelemetryUsageStatsPayload, TelemetryConfigStatsPayload } from './types';
-import { IReadinessManager } from '../../readiness/types';
-import { ISettings } from '../../types';
-/**
- * Converts `impressions` data from cache into request payload.
- */
-export declare function telemetryCacheStatsAdapter({ splits, segments, telemetry }: IStorageSync & {
-    telemetry: TelemetryCacheSync;
-}): {
-    isEmpty(): boolean;
-    clear(): void;
-    state(): TelemetryUsageStatsPayload;
-};
-export declare function telemetryCacheConfigAdapter(settings: ISettings, telemetryCache: TelemetryCacheSync): {
-    isEmpty(): boolean;
-    clear(): void;
-    state(): TelemetryConfigStatsPayload;
-};
-/**
- * Sync task that periodically posts impressions data
- */
-export declare function telemetrySyncTaskFactory(settings: ISettings, { postMetricsUsage, postMetricsConfig }: ISplitApi, storage: IStorageSync & {
-    telemetry: TelemetryCacheSync;
-}, telemetryRefreshRate: number, readiness: IReadinessManager, latencyTracker?: ITimeTracker): ISyncTask;

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

@@ -58,3 +58,110 @@ export declare type StoredEventWithMetadata = {
     /** Stored event */
     e: SplitIO.EventData;
 };
+/**
+ * Telemetry usage stats
+ */
+export declare type QUEUED = 0;
+export declare type DROPPED = 1;
+export declare type DEDUPED = 2;
+export declare type ImpressionDataType = QUEUED | DROPPED | DEDUPED;
+export declare type EventDataType = QUEUED | DROPPED;
+export declare type SPLITS = 'sp';
+export declare type IMPRESSIONS = 'im';
+export declare type IMPRESSIONS_COUNT = 'ic';
+export declare type EVENTS = 'ev';
+export declare type TELEMETRY = 'te';
+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, {
+    [statusCode: string]: number;
+}>;
+export declare type HttpLatencies = 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 CONNECTION_ESTABLISHED = 0;
+export declare type OCCUPANCY_PRI = 10;
+export declare type OCCUPANCY_SEC = 20;
+export declare type STREAMING_STATUS = 30;
+export declare type SSE_CONNECTION_ERROR = 40;
+export declare type TOKEN_REFRESH = 50;
+export declare type ABLY_ERROR = 60;
+export declare type SYNC_MODE_UPDATE = 70;
+export declare type StreamingEventType = CONNECTION_ESTABLISHED | OCCUPANCY_PRI | OCCUPANCY_SEC | STREAMING_STATUS | SSE_CONNECTION_ERROR | TOKEN_REFRESH | ABLY_ERROR | SYNC_MODE_UPDATE;
+export declare type StreamingEvent = {
+    e: StreamingEventType;
+    d?: number;
+    t: number;
+};
+export declare type TelemetryUsageStatsPayload = {
+    lS: LastSync;
+    mL: MethodLatencies;
+    mE: MethodExceptions;
+    hE: HttpErrors;
+    hL: HttpLatencies;
+    tR: number;
+    aR: number;
+    iQ: number;
+    iDe: number;
+    iDr: number;
+    spC: number;
+    seC: number;
+    skC: number;
+    sL?: number;
+    eQ: number;
+    eD: number;
+    sE: Array<StreamingEvent>;
+    t?: Array<string>;
+};
+/**
+ * Telemetry config stats
+ */
+export declare type STANDALONE_ENUM = 0;
+export declare type CONSUMER_ENUM = 1;
+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 RefreshRates = {
+    sp: number;
+    se: number;
+    im: number;
+    ev: number;
+    te: number;
+};
+export declare type UrlOverrides = {
+    s: boolean;
+    e: boolean;
+    a: boolean;
+    st: boolean;
+    t: boolean;
+};
+export declare type TelemetryConfigStatsPayload = {
+    oM?: OperationMode;
+    st: 'memory' | 'redis' | 'pluggable' | 'localstorage';
+    sE: boolean;
+    rR: RefreshRates;
+    uO: UrlOverrides;
+    iQ: number;
+    eQ: number;
+    iM: ImpressionsMode;
+    iL: boolean;
+    hP: boolean;
+    aF: number;
+    rF: number;
+    tR: number;
+    tC?: number;
+    nR: number;
+    t?: Array<string>;
+    i?: Array<string>;
+};

package/types/sync/syncManagerOnline.d.ts

@@ -1,6 +1,7 @@
-import { ISyncManagerCS, ISyncManagerFactoryParams } from './types';
+import { ISyncManagerCS } from './types';
 import { IPushManager } from './streaming/types';
 import { IPollingManager } from './polling/types';
+import { ISdkFactoryContextSync } from '../sdkFactory/types';
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -9,4 +10,4 @@ import { IPollingManager } from './polling/types';
  * `pollingManagerSSFactory` or `pollingManagerCSFactory` respectively.
  * @param pushManagerFactory optional to build a SyncManager with or without streaming support
  */
-export declare function syncManagerOnlineFactory(pollingManagerFactory?: (params: ISyncManagerFactoryParams) => IPollingManager, pushManagerFactory?: (params: ISyncManagerFactoryParams, pollingManager: IPollingManager) => IPushManager | undefined): (params: ISyncManagerFactoryParams) => ISyncManagerCS;
+export declare function syncManagerOnlineFactory(pollingManagerFactory?: (params: ISdkFactoryContextSync) => IPollingManager, pushManagerFactory?: (params: ISdkFactoryContextSync, pollingManager: IPollingManager) => IPushManager | undefined): (params: ISdkFactoryContextSync) => ISyncManagerCS;

package/types/sync/types.d.ts

@@ -1,8 +1,5 @@
 import { IReadinessManager } from '../readiness/types';
-import { IPlatform } from '../sdkFactory/types';
-import { ISplitApi } from '../services/types';
 import { IStorageSync } from '../storages/types';
-import { ISettings } from '../types';
 import { IPollingManager } from './polling/types';
 import { IPushManager } from './streaming/types';
 export interface ITask<Input extends any[] = []> {
@@ -33,9 +30,6 @@ export interface ISyncTask<Input extends any[] = [], Output = any> extends ITask
      */
     isExecuting(): boolean;
 }
-export interface ITimeTracker {
-    start(): () => void;
-}
 /** SyncManager */
 export interface ISyncManager extends ITask {
     flush(): Promise<any>;
@@ -46,10 +40,3 @@ export interface ISyncManager extends ITask {
 export interface ISyncManagerCS extends ISyncManager {
     shared(matchingKey: string, readinessManager: IReadinessManager, storage: IStorageSync): ISyncManager | undefined;
 }
-export interface ISyncManagerFactoryParams {
-    settings: ISettings;
-    readiness: IReadinessManager;
-    storage: IStorageSync;
-    splitApi: ISplitApi;
-    platform: IPlatform;
-}

package/types/trackers/eventTracker.d.ts

@@ -1,4 +1,4 @@
-import { IEventsCacheBase } from '../storages/types';
+import { IEventsCacheBase, ITelemetryCacheAsync, ITelemetryCacheSync } from '../storages/types';
 import { IEventsHandler, IEventTracker } from './types';
 import { ISettings } from '../types';
 /**
@@ -7,4 +7,4 @@ import { ISettings } from '../types';
  * @param eventsCache cache to save events
  * @param integrationsManager optional event handler used for integrations
  */
-export declare function eventTrackerFactory(settings: ISettings, eventsCache: IEventsCacheBase, integrationsManager?: IEventsHandler): IEventTracker;
+export declare function eventTrackerFactory(settings: ISettings, eventsCache: IEventsCacheBase, integrationsManager?: IEventsHandler, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IEventTracker;

package/types/trackers/impressionsTracker.d.ts

@@ -1,4 +1,4 @@
-import { IImpressionCountsCacheSync, IImpressionsCacheBase } from '../storages/types';
+import { IImpressionCountsCacheSync, IImpressionsCacheBase, ITelemetryCacheSync, ITelemetryCacheAsync } from '../storages/types';
 import { IImpressionsHandler, IImpressionsTracker } from './types';
 import { ISettings } from '../types';
 import { IImpressionObserver } from './impressionObserver/types';
@@ -12,4 +12,4 @@ import { IImpressionObserver } from './impressionObserver/types';
  * @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)
  */
-export declare function impressionsTrackerFactory(settings: ISettings, impressionsCache: IImpressionsCacheBase, integrationsManager?: IImpressionsHandler, observer?: IImpressionObserver, countsCache?: IImpressionCountsCacheSync): IImpressionsTracker;
+export declare function impressionsTrackerFactory(settings: ISettings, impressionsCache: IImpressionsCacheBase, integrationsManager?: IImpressionsHandler, observer?: IImpressionObserver, countsCache?: IImpressionCountsCacheSync, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IImpressionsTracker;

package/types/trackers/telemetryTracker.d.ts

@@ -1,4 +1,3 @@
-import { TelemetryCacheAsync, TelemetryCacheSync } from '../storages/types';
-import { ISettings } from '../types';
+import { ITelemetryCacheSync, ITelemetryCacheAsync } from '../storages/types';
 import { ITelemetryTracker } from './types';
-export declare function telemetryTrackerFactory(settings: ISettings, telemetryCache?: TelemetryCacheAsync | TelemetryCacheSync, now?: () => number): ITelemetryTracker;
+export declare function telemetryTrackerFactory(telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync, now?: () => number): ITelemetryTracker;

package/types/trackers/types.d.ts

@@ -1,5 +1,7 @@
 import { SplitIO, ImpressionDTO } from '../types';
+import { StreamingEventType, Method, OperationType } from '../sync/submitters/types';
 import { IEventsCacheBase } from '../storages/types';
+import { NetworkError } from '../services/types';
 /** Events tracker */
 export interface IEventsHandler {
     handleEvent(eventData: SplitIO.EventData): any;
@@ -12,3 +14,23 @@ export interface IImpressionsHandler {
 export interface IImpressionsTracker {
     track(impressions: ImpressionDTO[], attributes?: SplitIO.Attributes): void;
 }
+/** Telemetry tracker */
+export declare type AUTH_REJECTION = 80;
+export interface ITelemetryTracker {
+    /**
+     * Creates a telemetry evaluator tracker, to record Latencies, Exceptions and NonReadyUsage of client operations (getTreatments and track method calls)
+     */
+    trackEval(method: Method): (label?: string) => void;
+    /**
+     * Creates a telemetry runtime tracker, to record Latencies and Exceptions of HTTP requests
+     */
+    trackHttp(method: OperationType): (error?: NetworkError) => void;
+    /**
+     * Records session length
+     */
+    sessionLength(): void;
+    /**
+     * Records streaming event
+     */
+    streamingEvent(e: StreamingEventType | AUTH_REJECTION, d?: number): void;
+}