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

package/src/utils/timeTracker/timer.ts

@@ -1,7 +1,7 @@
-export function timer(now?: () => number) {
-  const st = now ? now() : Date.now();
+export function timer(now: () => number) {
+  const st = now();
 
   return function stop() {
-    return Math.round(now ? now() : Date.now() - st);
+    return Math.round(now() - st);
   };
 }

package/types/logger/constants.d.ts

@@ -120,6 +120,7 @@ export declare const ERROR_HTTP = 322;
 export declare const ERROR_LOCALHOST_MODULE_REQUIRED = 323;
 export declare const ERROR_STORAGE_INVALID = 324;
 export declare const ERROR_NOT_BOOLEAN = 325;
+export declare const ERROR_MIN_CONFIG_PARAM = 326;
 export declare const LOG_PREFIX_SETTINGS = "settings";
 export declare const LOG_PREFIX_INSTANTIATION = "Factory instantiation";
 export declare const LOG_PREFIX_ENGINE = "engine";

package/types/sdkFactory/types.d.ts

@@ -1,22 +1,13 @@
 import { IIntegrationManager, IIntegrationFactoryParams } from '../integrations/types';
 import { ISignalListener } from '../listeners/types';
 import { ILogger } from '../logger/types';
-import { ISdkReadinessManager } from '../readiness/types';
+import { IReadinessManager, ISdkReadinessManager } from '../readiness/types';
 import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
 import { IStorageAsync, IStorageSync, ISplitsCacheSync, ISplitsCacheAsync, IStorageFactoryParams } from '../storages/types';
-import { ISyncManager, ISyncManagerFactoryParams } from '../sync/types';
+import { ISyncManager } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
-import { IImpressionsTracker, IEventTracker } from '../trackers/types';
+import { IImpressionsTracker, IEventTracker, ITelemetryTracker } from '../trackers/types';
 import { SplitIO, ISettings, IEventEmitter } from '../types';
-export interface ISdkFactoryContext {
-    storage: IStorageSync | IStorageAsync;
-    sdkReadinessManager: ISdkReadinessManager;
-    settings: ISettings;
-    impressionsTracker: IImpressionsTracker;
-    eventTracker: IEventTracker;
-    signalListener?: ISignalListener;
-    syncManager?: ISyncManager;
-}
 /**
  * Environment related dependencies.
  * These getters are called a fixed number of times per factory instantiation.
@@ -26,6 +17,30 @@ export interface IPlatform {
     getFetch?: () => (IFetch | undefined);
     getEventSource?: () => (IEventSourceConstructor | undefined);
     EventEmitter: new () => IEventEmitter;
+    now?: () => number;
+}
+export interface ISdkFactoryContext {
+    platform: IPlatform;
+    sdkReadinessManager: ISdkReadinessManager;
+    readiness: IReadinessManager;
+    settings: ISettings;
+    impressionsTracker: IImpressionsTracker;
+    eventTracker: IEventTracker;
+    telemetryTracker: ITelemetryTracker;
+    storage: IStorageSync | IStorageAsync;
+    signalListener?: ISignalListener;
+    splitApi?: ISplitApi;
+    syncManager?: ISyncManager;
+}
+export interface ISdkFactoryContextSync extends ISdkFactoryContext {
+    storage: IStorageSync;
+    splitApi: ISplitApi;
+    syncManager: ISyncManager;
+}
+export interface ISdkFactoryContextAsync extends ISdkFactoryContext {
+    storage: IStorageAsync;
+    splitApi: undefined;
+    syncManager: undefined;
 }
 /**
  * Object parameter with the modules required to create an SDK factory instance
@@ -34,8 +49,8 @@ export interface ISdkFactoryParams {
     settings: ISettings;
     platform: IPlatform;
     storageFactory: (params: IStorageFactoryParams) => IStorageSync | IStorageAsync;
-    splitApiFactory?: (settings: ISettings, platform: IPlatform) => ISplitApi;
-    syncManagerFactory?: (params: ISyncManagerFactoryParams) => ISyncManager;
+    splitApiFactory?: (settings: ISettings, platform: IPlatform, telemetryTracker: ITelemetryTracker) => ISplitApi;
+    syncManagerFactory?: (params: ISdkFactoryContextSync) => ISyncManager;
     sdkManagerFactory: (log: ILogger, splits: ISplitsCacheSync | ISplitsCacheAsync, sdkReadinessManager: ISdkReadinessManager) => SplitIO.IManager | SplitIO.IAsyncManager;
     sdkClientMethodFactory: (params: ISdkFactoryContext) => ({
         (): SplitIO.ICsClient;

package/types/services/splitApi.d.ts

@@ -1,10 +1,11 @@
 import { IPlatform } from '../sdkFactory/types';
 import { ISettings } from '../types';
 import { ISplitApi } from './types';
+import { ITelemetryTracker } from '../trackers/types';
 /**
  * Factory of SplitApi objects, which group the collection of Split HTTP endpoints used by the SDK
  *
  * @param settings validated settings object
  * @param platform object containing environment-specific `getFetch` and `getOptions` dependencies
  */
-export declare function splitApiFactory(settings: Pick<ISettings, 'urls' | 'sync' | 'log' | 'version' | 'runtime' | 'core'>, platform: Pick<IPlatform, 'getFetch' | 'getOptions'>): ISplitApi;
+export declare function splitApiFactory(settings: Pick<ISettings, 'urls' | 'sync' | 'log' | 'version' | 'runtime' | 'core'>, platform: Pick<IPlatform, 'getFetch' | 'getOptions'>, telemetryTracker: ITelemetryTracker): ISplitApi;

package/types/services/types.d.ts

@@ -9,9 +9,12 @@ export declare type IResponse = {
     json: () => Promise<any>;
     text: () => Promise<string>;
 };
+export declare type NetworkError = Error & {
+    statusCode?: number;
+};
 export declare type IFetch = (url: string, options?: IRequestOptions) => Promise<IResponse>;
 export declare type IHealthCheckAPI = () => Promise<boolean>;
-export declare type ISplitHttpClient = (url: string, options?: IRequestOptions, logErrorsAsInfo?: boolean) => Promise<IResponse>;
+export declare type ISplitHttpClient = (url: string, options?: IRequestOptions, latencyTracker?: (error?: NetworkError) => void, logErrorsAsInfo?: boolean) => Promise<IResponse>;
 export declare type IFetchAuth = (userKeys?: string[]) => Promise<IResponse>;
 export declare type IFetchSplitChanges = (since: number, noCache?: boolean) => Promise<IResponse>;
 export declare type IFetchSegmentChanges = (since: number, segmentName: string, noCache?: boolean) => Promise<IResponse>;
@@ -19,8 +22,8 @@ export declare type IFetchMySegments = (userMatchingKey: string, noCache?: boole
 export declare type IPostEventsBulk = (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 IPostMetricsCounters = (body: string) => Promise<IResponse>;
-export declare type IPostMetricsTimes = (body: string) => Promise<IResponse>;
+export declare type IPostMetricsConfig = (body: string) => Promise<IResponse>;
+export declare type IPostMetricsUsage = (body: string) => Promise<IResponse>;
 export interface ISplitApi {
     getSdkAPIHealthCheck: IHealthCheckAPI;
     getEventsAPIHealthCheck: IHealthCheckAPI;
@@ -31,8 +34,8 @@ export interface ISplitApi {
     postEventsBulk: IPostEventsBulk;
     postTestImpressionsBulk: IPostTestImpressionsBulk;
     postTestImpressionsCount: IPostTestImpressionsCount;
-    postMetricsCounters: IPostMetricsCounters;
-    postMetricsTimes: IPostMetricsTimes;
+    postMetricsConfig: IPostMetricsConfig;
+    postMetricsUsage: IPostMetricsUsage;
 }
 interface EventSourceEventMap {
     'error': Event;

package/types/storages/AbstractSegmentsCacheSync.d.ts

@@ -29,10 +29,14 @@ export declare abstract class AbstractSegmentsCacheSync implements ISegmentsCach
      */
     registerSegments(names: string[]): boolean;
     /**
-     * For server-side synchronizer: get the list of segments in the cache.
-     * For client-side synchronizer: the method is not used.
+     * For server-side synchronizer: get the list of segments to fetch changes.
+     * Also used for the `seC` (segment count) telemetry stat.
+     */
+    abstract getRegisteredSegments(): string[];
+    /**
+     * Only used for the `skC`(segment keys count) telemetry stat: 1 for client-side, and total count of keys in server-side.
      */
-    getRegisteredSegments(): string[];
+    abstract getKeysCount(): number;
     /**
      * For server-side synchronizer: set the change number of `name` segment.
      * For client-side synchronizer: the method is not used.

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/polling/syncTasks/splitsSyncTask.d.ts

@@ -6,4 +6,4 @@ import { ISettings } from '../../../types';
 /**
  * Creates a sync task that periodically executes a `splitChangesUpdater` task
  */
-export declare function splitsSyncTaskFactory(fetchSplitChanges: IFetchSplitChanges, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings): ISplitsSyncTask;
+export declare function splitsSyncTaskFactory(fetchSplitChanges: IFetchSplitChanges, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings, isClientSide?: boolean): ISplitsSyncTask;

package/types/sync/polling/updaters/splitChangesUpdater.d.ts

@@ -35,5 +35,5 @@ export declare function computeSplitsMutation(entries: ISplit[]): ISplitMutation
  * @param requestTimeoutBeforeReady  How long the updater will wait for the request to timeout. Default 0, i.e., never timeout.
  * @param retriesOnFailureBeforeReady  How many retries on `/splitChanges` we the updater do in case of failure or timeout. Default 0, i.e., no retries.
  */
-export declare function splitChangesUpdaterFactory(log: ILogger, splitChangesFetcher: ISplitChangesFetcher, splits: ISplitsCacheBase, segments: ISegmentsCacheBase, splitsEventEmitter?: ISplitsEventEmitter, requestTimeoutBeforeReady?: number, retriesOnFailureBeforeReady?: number): ISplitChangesUpdater;
+export declare function splitChangesUpdaterFactory(log: ILogger, splitChangesFetcher: ISplitChangesFetcher, splits: ISplitsCacheBase, segments: ISegmentsCacheBase, splitsEventEmitter?: ISplitsEventEmitter, requestTimeoutBeforeReady?: number, retriesOnFailureBeforeReady?: number, isClientSide?: boolean): ISplitChangesUpdater;
 export {};

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;