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

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

@@ -0,0 +1,39 @@
+import { ISet } from '../../../utils/lang/sets';
+import { ISegmentsCacheBase, ISplitsCacheBase } from '../../../storages/types';
+import { ISplitChangesFetcher } from '../fetchers/types';
+import { ISplit } from '../../../dtos/types';
+import { ISplitsEventEmitter } from '../../../readiness/types';
+import { ILogger } from '../../../logger/types';
+declare type ISplitChangesUpdater = (noCache?: boolean, till?: number) => Promise<boolean>;
+/**
+ * Collect segments from a raw split definition.
+ * Exported for testing purposes.
+ */
+export declare function parseSegments({ conditions }: ISplit): ISet<string>;
+interface ISplitMutations {
+    added: [string, ISplit][];
+    removed: string[];
+    segments: string[];
+}
+/**
+ * Given the list of splits from /splitChanges endpoint, it returns the mutations,
+ * i.e., an object with added splits, removed splits and used segments.
+ * Exported for testing purposes.
+ */
+export declare function computeSplitsMutation(entries: ISplit[]): ISplitMutations;
+/**
+ * factory of SplitChanges updater, a task that:
+ *  - fetches split changes using `splitChangesFetcher`
+ *  - updates `splitsCache`
+ *  - uses `splitsEventEmitter` to emit events related to split data updates
+ *
+ * @param log  Logger instance
+ * @param splitChangesFetcher  Fetcher of `/splitChanges`
+ * @param splits  Splits storage, with sync or async methods
+ * @param segments  Segments storage, with sync or async methods
+ * @param splitsEventEmitter  Optional readiness manager. Not required for synchronizer or producer mode.
+ * @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, isClientSide?: boolean): ISplitChangesUpdater;
+export {};

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

@@ -0,0 +1,12 @@
+import { IFetchAuth } from '../../../services/types';
+import { IAuthenticate } from './types';
+/**
+ * Factory of authentication function.
+ *
+ * @param fetchAuth `SplitAPI.fetchAuth` endpoint
+ */
+export declare function authenticateFactory(fetchAuth: IFetchAuth): IAuthenticate;
+/**
+ * Returns the hash of a given user key
+ */
+export declare function hashUserKey(userKey: string): string;

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

@@ -0,0 +1,17 @@
+import { IDecodedJWTToken } from '../../../utils/jwt/types';
+export interface IAuthTokenPushEnabled {
+    pushEnabled: true;
+    token: string;
+    decodedToken: IDecodedJWTToken;
+    channels: {
+        [channel: string]: string[];
+    };
+    connDelay?: number;
+}
+export interface IAuthTokenPushDisabled {
+    pushEnabled: false;
+    token: '';
+}
+export declare type IAuthToken = IAuthTokenPushDisabled | IAuthTokenPushEnabled;
+export declare type IAuthenticate = (userKeys?: string[]) => Promise<IAuthToken>;
+export declare type IAuthenticateV2 = (isClientSide?: boolean) => Promise<IAuthToken>;

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

@@ -0,0 +1,34 @@
+import { IEventSourceConstructor } from '../../../services/types';
+import { ISettings } from '../../../types';
+import { IAuthTokenPushEnabled } from '../AuthClient/types';
+import { ISSEClient, ISseEventHandler } from './types';
+/**
+ * Handles streaming connections with EventSource API
+ */
+export declare class SSEClient implements ISSEClient {
+    eventSource?: IEventSourceConstructor;
+    streamingUrl: string;
+    connection?: InstanceType<IEventSourceConstructor>;
+    handler?: ISseEventHandler;
+    useHeaders?: boolean;
+    headers: Record<string, string>;
+    /**
+     * SSEClient constructor.
+     *
+     * @param settings Validated settings.
+     * @param useHeaders True to send metadata as headers or false to send as query params. If `true`, the provided EventSource must support headers.
+     * @param getEventSource Function to get the EventSource constructor.
+     * @throws 'EventSource API is not available. ' if EventSource is not available.
+     */
+    constructor(settings: ISettings, useHeaders?: boolean, getEventSource?: () => (IEventSourceConstructor | undefined));
+    setEventHandler(handler: ISseEventHandler): void;
+    /**
+     * Open the connection with a given authToken
+     *
+     * @param {IAuthTokenPushEnabled} authToken
+     * @throws {TypeError} Will throw an error if `authToken` is undefined
+     */
+    open(authToken: IAuthTokenPushEnabled): void;
+    /** Close connection  */
+    close(): void;
+}

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

@@ -0,0 +1,11 @@
+import { IAuthTokenPushEnabled } from '../AuthClient/types';
+export interface ISseEventHandler {
+    handleError: (ev: Event) => any;
+    handleMessage: (ev: MessageEvent) => any;
+    handleOpen: () => any;
+}
+export interface ISSEClient {
+    open(authToken: IAuthTokenPushEnabled): void;
+    close(): void;
+    setEventHandler(handler: ISseEventHandler): void;
+}

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

@@ -0,0 +1,14 @@
+import { ITelemetryTracker } from '../../../trackers/types';
+import { ControlType } from '../constants';
+import { IPushEventEmitter } from '../types';
+/**
+ * Factory of notification keeper, which process OCCUPANCY and CONTROL notifications and emits the corresponding push events.
+ *
+ * @param pushEmitter emitter for events related to streaming support
+ */
+export declare function notificationKeeperFactory(pushEmitter: IPushEventEmitter, telemetryTracker: ITelemetryTracker): {
+    handleOpen(): void;
+    isStreamingUp(): boolean;
+    handleOccupancyEvent(publishers: number, channel: string, timestamp: number): void;
+    handleControlEvent(controlType: ControlType, channel: string, timestamp: number): void;
+};

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

@@ -0,0 +1,20 @@
+import { INotificationMessage, INotificationError } from './types';
+/**
+ * Parses the `data` JSON string, if exists, of a given SSE error notifications.
+ * HTTP errors handled by Ably (e.g., 400 due to invalid token, 401 due to expired token, 500) have the `data` property.
+ * Other network and HTTP errors do not have this property.
+ *
+ * @param {Object} error
+ * @throws {SyntaxError} if `error.data` is an invalid JSON string
+ */
+export declare function errorParser(error: Event): INotificationError;
+/**
+ * Parses the `data` JSON string of a given SSE message notifications.
+ * Also assigns the type OCCUPANCY, if it corresponds, so that all supported messages (e.g., SPLIT_UPDATE, CONTROL) have a type.
+ *
+ * @param message
+ * @returns parsed notification message or undefined if the given event data is falsy (e.g, '' or undefined).
+ * For example, the EventSource implementation of React-Native for iOS emits a message event with empty data for Ably keepalive comments.
+ * @throws {SyntaxError} if `message.data` or `JSON.parse(message.data).data` are invalid JSON strings
+ */
+export declare function messageParser(message: MessageEvent): INotificationMessage | undefined;

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

@@ -0,0 +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, telemetryTracker: ITelemetryTracker): ISseEventHandler;

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

@@ -0,0 +1,67 @@
+import { ControlType } from '../constants';
+import { MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY } from '../types';
+export interface IMySegmentsUpdateData {
+    type: MY_SEGMENTS_UPDATE;
+    changeNumber: number;
+    includesPayload: boolean;
+    segmentList?: string[];
+}
+export declare enum Compression {
+    None = 0,
+    Gzip = 1,
+    Zlib = 2
+}
+export declare enum UpdateStrategy {
+    UnboundedFetchRequest = 0,
+    BoundedFetchRequest = 1,
+    KeyList = 2,
+    SegmentRemoval = 3
+}
+export interface KeyList {
+    a?: string[];
+    r?: string[];
+}
+export interface IMySegmentsUpdateV2Data {
+    type: MY_SEGMENTS_UPDATE_V2;
+    changeNumber: number;
+    segmentName: string;
+    c: Compression;
+    d: string;
+    u: UpdateStrategy;
+}
+export interface ISegmentUpdateData {
+    type: SEGMENT_UPDATE;
+    changeNumber: number;
+    segmentName: string;
+}
+export interface ISplitUpdateData {
+    type: SPLIT_UPDATE;
+    changeNumber: number;
+}
+export interface ISplitKillData {
+    type: SPLIT_KILL;
+    changeNumber: number;
+    splitName: string;
+    defaultTreatment: string;
+}
+export interface IControlData {
+    type: CONTROL;
+    controlType: ControlType;
+}
+export interface IOccupancyData {
+    type: OCCUPANCY;
+    metrics: {
+        publishers: number;
+    };
+}
+export declare type INotificationData = IMySegmentsUpdateData | IMySegmentsUpdateV2Data | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData;
+export declare type INotificationMessage = {
+    parsedData: INotificationData;
+    channel: string;
+    timestamp: number;
+    data: string;
+};
+export declare type INotificationError = Event & {
+    parsedData?: any;
+    message?: string;
+};

package/types/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.d.ts

@@ -0,0 +1,6 @@
+import { IMySegmentsSyncTask } from '../../polling/types';
+import { IUpdateWorker } from './types';
+/**
+ * MySegmentsUpdateWorker factory
+ */
+export declare function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask): IUpdateWorker;

package/types/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.d.ts

@@ -0,0 +1,8 @@
+import { ILogger } from '../../../logger/types';
+import { ISegmentsCacheSync } from '../../../storages/types';
+import { ISegmentsSyncTask } from '../../polling/types';
+import { IUpdateWorker } from './types';
+/**
+ * SegmentsUpdateWorker factory
+ */
+export declare function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync): IUpdateWorker;

package/types/sync/streaming/UpdateWorkers/SplitsUpdateWorker.d.ts

@@ -0,0 +1,12 @@
+import { ILogger } from '../../../logger/types';
+import { ISplitsEventEmitter } from '../../../readiness/types';
+import { ISplitsCacheSync } from '../../../storages/types';
+import { ISegmentsSyncTask, ISplitsSyncTask } from '../../polling/types';
+import { ISplitKillData } from '../SSEHandler/types';
+import { IUpdateWorker } from './types';
+/**
+ * SplitsUpdateWorker factory
+ */
+export declare function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker & {
+    killSplit(event: ISplitKillData): void;
+};

package/types/sync/streaming/UpdateWorkers/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const FETCH_BACKOFF_BASE = 10000;
+export declare const FETCH_BACKOFF_MAX_WAIT = 60000;
+export declare const FETCH_BACKOFF_MAX_RETRIES = 10;

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

@@ -0,0 +1,4 @@
+export interface IUpdateWorker {
+    stop(): void;
+    put(...args: any[]): void;
+}

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

@@ -0,0 +1,34 @@
+export declare const SECONDS_BEFORE_EXPIRATION = 600;
+/**
+ * emitted on SSE and Authenticate non-recoverable errors, STREAMING_DISABLED control notification and authentication with pushEnabled false
+ * triggers `handleNonRetryableError` call
+ */
+export declare const PUSH_NONRETRYABLE_ERROR = "PUSH_NONRETRYABLE_ERROR";
+/**
+ * emitted on SSE and Authenticate recoverable errors
+ * triggers `handleRetryableError` call
+ */
+export declare const PUSH_RETRYABLE_ERROR = "PUSH_RETRYABLE_ERROR";
+/**
+ * emitted on STREAMING_RESUMED control notification, OCCUPANCY different than 0, and SSE onopen event
+ * triggers `stopPollingAndSyncAll` call
+ */
+export declare const PUSH_SUBSYSTEM_UP = "PUSH_SUBSYSTEM_UP";
+/**
+ * emitted on STREAMING_PAUSED control notification, OCCUPANCY equal to 0, PUSH_NONRETRYABLE_ERROR and PUSH_RETRYABLE_ERROR events.
+ * triggers `startPolling` and `stopWorkers` calls
+ */
+export declare const PUSH_SUBSYSTEM_DOWN = "PUSH_SUBSYSTEM_DOWN";
+export declare const MY_SEGMENTS_UPDATE = "MY_SEGMENTS_UPDATE";
+export declare const MY_SEGMENTS_UPDATE_V2 = "MY_SEGMENTS_UPDATE_V2";
+export declare const SEGMENT_UPDATE = "SEGMENT_UPDATE";
+export declare const SPLIT_KILL = "SPLIT_KILL";
+export declare const SPLIT_UPDATE = "SPLIT_UPDATE";
+export declare const CONTROL = "CONTROL";
+export declare const OCCUPANCY = "OCCUPANCY";
+export declare enum ControlType {
+    STREAMING_DISABLED = "STREAMING_DISABLED",
+    STREAMING_PAUSED = "STREAMING_PAUSED",
+    STREAMING_RESUMED = "STREAMING_RESUMED",
+    STREAMING_RESET = "STREAMING_RESET"
+}

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

@@ -0,0 +1,27 @@
+import { Compression, KeyList } from './SSEHandler/types';
+/**
+ * Decode, decompress and parse the provided 'data' into a KeyList object
+ *
+ * @param {string} data
+ * @param {number} compression
+ * @returns {{a?: string[], r?: string[] }}
+ * @throws if data string cannot be decoded, decompressed or parsed
+ */
+export declare function parseKeyList(data: string, compression: Compression): KeyList;
+/**
+ * Decode, decompress and parse the provided 'data' into a Bitmap object
+ *
+ * @param {string} data
+ * @param {number} compression
+ * @returns {Uint8Array}
+ * @throws if data string cannot be decoded or decompressed
+ */
+export declare function parseBitmap(data: string, compression: Compression): Uint8Array;
+/**
+ * Check if the 'bitmap' bit at 'hash64hex' position is 1
+ *
+ * @param {Uint8Array} bitmap
+ * @param {string} hash64hex 16-chars string, representing a number in hexa
+ * @returns {boolean}
+ */
+export declare function isInBitmap(bitmap: Uint8Array, hash64hex: string): boolean;

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

@@ -0,0 +1,9 @@
+import { IPushManager } from './types';
+import { IPollingManager } from '../polling/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: ISdkFactoryContextSync, pollingManager: IPollingManager): IPushManager | undefined;

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

@@ -0,0 +1,35 @@
+import { IMySegmentsUpdateData, IMySegmentsUpdateV2Data, ISegmentUpdateData, ISplitUpdateData, ISplitKillData } from './SSEHandler/types';
+import { ITask } from '../types';
+import { IMySegmentsSyncTask } from '../polling/types';
+import { IEventEmitter } from '../../types';
+import { ControlType } from './constants';
+export declare type PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP';
+export declare type PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN';
+export declare type PUSH_NONRETRYABLE_ERROR = 'PUSH_NONRETRYABLE_ERROR';
+export declare type PUSH_RETRYABLE_ERROR = 'PUSH_RETRYABLE_ERROR';
+export declare type MY_SEGMENTS_UPDATE = 'MY_SEGMENTS_UPDATE';
+export declare type MY_SEGMENTS_UPDATE_V2 = 'MY_SEGMENTS_UPDATE_V2';
+export declare type SEGMENT_UPDATE = 'SEGMENT_UPDATE';
+export declare type SPLIT_KILL = 'SPLIT_KILL';
+export declare type SPLIT_UPDATE = 'SPLIT_UPDATE';
+export declare type CONTROL = 'CONTROL';
+export declare type OCCUPANCY = 'OCCUPANCY';
+export declare type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NONRETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MY_SEGMENTS_UPDATE | MY_SEGMENTS_UPDATE_V2 | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | ControlType.STREAMING_RESET;
+declare type IParsedData<T extends IPushEvent> = T extends MY_SEGMENTS_UPDATE ? IMySegmentsUpdateData : T extends MY_SEGMENTS_UPDATE_V2 ? IMySegmentsUpdateV2Data : T extends SEGMENT_UPDATE ? ISegmentUpdateData : T extends SPLIT_UPDATE ? ISplitUpdateData : T extends SPLIT_KILL ? ISplitKillData : undefined;
+/**
+ * EventEmitter used as Feedback Loop between the SyncManager and PushManager,
+ * where the latter pushes messages and the former consumes it
+ */
+export interface IPushEventEmitter extends IEventEmitter {
+    once<T extends IPushEvent>(event: T, listener: (parsedData: IParsedData<T>, channel: T extends MY_SEGMENTS_UPDATE ? string : undefined) => void): this;
+    on<T extends IPushEvent>(event: T, listener: (parsedData: IParsedData<T>, channel: T extends MY_SEGMENTS_UPDATE ? string : undefined) => void): this;
+    emit<T extends IPushEvent>(event: T, parsedData?: IParsedData<T>, channel?: T extends MY_SEGMENTS_UPDATE ? string : undefined): boolean;
+}
+/**
+ * PushManager
+ */
+export interface IPushManager extends ITask, IPushEventEmitter {
+    add(userKey: string, mySegmentsSyncTask: IMySegmentsSyncTask): void;
+    remove(userKey: string): void;
+}
+export {};

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

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

package/types/sync/submitters/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/impressionCountsSubmitterInRedis.d.ts

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

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

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

package/types/sync/submitters/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/impressionsSyncTask.d.ts

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

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

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

package/types/sync/submitters/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<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>;
+/**
+ * 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

@@ -0,0 +1,3 @@
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+import { ISubmitterManager } from './types';
+export declare function submitterManagerFactory(params: ISdkFactoryContextSync): ISubmitterManager;

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

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

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

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