@splitsoftware/splitio-commons 1.8.3-rc.3 → 1.8.4-rc.0

package/src/sync/streaming/UpdateWorkers/SplitsUpdateWorker.ts

@@ -1,8 +1,11 @@
+import { ISplit } from '../../../dtos/types';
 import { ILogger } from '../../../logger/types';
 import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
 import { ISplitsEventEmitter } from '../../../readiness/types';
 import { ISplitsCacheSync } from '../../../storages/types';
+import { ITelemetryTracker } from '../../../trackers/types';
 import { Backoff } from '../../../utils/Backoff';
+import { SPLITS } from '../../../utils/constants';
 import { ISegmentsSyncTask, ISplitsSyncTask } from '../../polling/types';
 import { ISplitKillData, ISplitUpdateData } from '../SSEHandler/types';
 import { FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT, FETCH_BACKOFF_MAX_RETRIES } from './constants';
@@ -11,25 +14,27 @@ import { IUpdateWorker } from './types';
 /**
  * SplitsUpdateWorker factory
  */
-export function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker & { killSplit(event: ISplitKillData): void } {
+export function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker & { killSplit(event: ISplitKillData): void } {
 
   let maxChangeNumber = 0;
   let handleNewEvent = false;
   let isHandlingEvent: boolean;
   let cdnBypass: boolean;
+  let payload: ISplit | undefined;
   const backoff = new Backoff(__handleSplitUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
 
   function __handleSplitUpdateCall() {
     isHandlingEvent = true;
     if (maxChangeNumber > splitsCache.getChangeNumber()) {
       handleNewEvent = false;
-
+      const splitUpdateNotification = payload ? { payload, changeNumber: maxChangeNumber } : undefined;
       // fetch splits revalidating data if cached
-      splitsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined).then(() => {
+      splitsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined, splitUpdateNotification).then(() => {
         if (!isHandlingEvent) return; // halt if `stop` has been called
         if (handleNewEvent) {
           __handleSplitUpdateCall();
         } else {
+          if (splitUpdateNotification) telemetryTracker.trackUpdatesFromSSE(SPLITS);
           // fetch new registered segments for server-side API. Not retrying on error
           if (segmentsSyncTask) segmentsSyncTask.execute(true);
 
@@ -66,7 +71,7 @@ export function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync,
    *
    * @param {number} changeNumber change number of the SPLIT_UPDATE notification
    */
-  function put({ changeNumber }: Pick<ISplitUpdateData, 'changeNumber'>) {
+  function put({ changeNumber, pcn }: ISplitUpdateData, _payload?: ISplit) {
     const currentChangeNumber = splitsCache.getChangeNumber();
 
     if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber) return;
@@ -74,6 +79,11 @@ export function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync,
     maxChangeNumber = changeNumber;
     handleNewEvent = true;
     cdnBypass = false;
+    payload = undefined;
+
+    if (_payload && currentChangeNumber === pcn) {
+      payload = _payload;
+    }
 
     if (backoff.timeoutID || !isHandlingEvent) __handleSplitUpdateCall();
     backoff.reset();
@@ -81,7 +91,6 @@ export function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync,
 
   return {
     put,
-
     /**
      * Invoked by NotificationProcessor on SPLIT_KILL event
      *
@@ -95,7 +104,7 @@ export function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync,
         splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, true);
       }
       // queues the SplitChanges fetch (only if changeNumber is newer)
-      put({ changeNumber });
+      put({ changeNumber } as ISplitUpdateData);
     },
 
     stop() {

package/src/sync/streaming/pushManager.ts

@@ -14,7 +14,7 @@ import { getMatching } from '../../utils/key';
 import { MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
 import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 } from '../../logger/constants';
 import { KeyList, UpdateStrategy } from './SSEHandler/types';
-import { isInBitmap, parseBitmap, parseKeyList } from './parseUtils';
+import { isInBitmap, parseBitmap, parseFFUpdatePayload, parseKeyList } from './parseUtils';
 import { ISet, _Set } from '../../utils/lang/sets';
 import { Hash64, hash64 } from '../../utils/murmur3/murmur3_64';
 import { IAuthTokenPushEnabled } from './AuthClient/types';
@@ -58,7 +58,7 @@ export function pushManagerFactory(
   // MySegmentsUpdateWorker (client-side) are initiated in `add` method
   const segmentsUpdateWorker = userKey ? undefined : SegmentsUpdateWorker(log, pollingManager.segmentsSyncTask as ISegmentsSyncTask, storage.segments);
   // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
-  const splitsUpdateWorker = SplitsUpdateWorker(log, storage.splits, pollingManager.splitsSyncTask, readiness.splits, userKey ? undefined : pollingManager.segmentsSyncTask as ISegmentsSyncTask);
+  const splitsUpdateWorker = SplitsUpdateWorker(log, storage.splits, pollingManager.splitsSyncTask, readiness.splits, telemetryTracker, userKey ? undefined : pollingManager.segmentsSyncTask as ISegmentsSyncTask);
 
   // [Only for client-side] map of hashes to user keys, to dispatch MY_SEGMENTS_UPDATE events to the corresponding MySegmentsUpdateWorker
   const userKeyHashes: Record<string, string> = {};
@@ -221,7 +221,21 @@ export function pushManagerFactory(
   /** Functions related to synchronization (Queues and Workers in the spec) */
 
   pushEmitter.on(SPLIT_KILL, splitsUpdateWorker.killSplit);
-  pushEmitter.on(SPLIT_UPDATE, splitsUpdateWorker.put);
+  pushEmitter.on(SPLIT_UPDATE, (parsedData) => {
+    if (parsedData.d && parsedData.c !== undefined) {
+      try {
+        const payload = parseFFUpdatePayload(parsedData.c, parsedData.d);
+        if (payload) {
+          splitsUpdateWorker.put(parsedData, payload);
+          return;
+        }
+      } catch (e) {
+        // @TODO define a error code for feature flags parsing
+        log.debug(e);
+      }
+    }
+    splitsUpdateWorker.put(parsedData);
+  });
 
   if (userKey) {
     pushEmitter.on(MY_SEGMENTS_UPDATE, function handleMySegmentsUpdate(parsedData, channel) {
@@ -330,7 +344,7 @@ export function pushManagerFactory(
 
         if (!userKeyHashes[hash]) {
           userKeyHashes[hash] = userKey;
-          clients[userKey] = { hash64: hash64(userKey), worker: MySegmentsUpdateWorker(mySegmentsSyncTask) };
+          clients[userKey] = { hash64: hash64(userKey), worker: MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker) };
           connectForNewClient = true; // we must reconnect on start, to listen the channel for the new user key
 
           // Reconnects in case of a new client.

package/src/sync/submitters/types.ts

@@ -103,6 +103,7 @@ export type DROPPED = 1;
 export type DEDUPED = 2;
 export type ImpressionDataType = QUEUED | DROPPED | DEDUPED
 export type EventDataType = QUEUED | DROPPED;
+export type UpdatesFromSSEEnum = SPLITS | MY_SEGMENT;
 
 export type SPLITS = 'sp';
 export type IMPRESSIONS = 'im';
@@ -151,6 +152,12 @@ export type TelemetryUsageStats = {
   mE?: MethodExceptions, // methodExceptions
 }
 
+// amount of instant updates that we are doing by avoiding fetching to Split servers
+export type UpdatesFromSSE = {
+  sp: number, // splits
+  ms?: number, // my segments
+}
+
 // 'metrics/usage' JSON request body
 export type TelemetryUsageStatsPayload = TelemetryUsageStats & {
   lS: LastSync, // lastSynchronization
@@ -169,6 +176,7 @@ export type TelemetryUsageStatsPayload = TelemetryUsageStats & {
   eD: number, // eventsDropped
   sE: Array<StreamingEvent>, // streamingEvents
   t?: Array<string>, // tags
+  ufs?: UpdatesFromSSE, //UpdatesFromSSE
 }
 
 /**

package/src/trackers/telemetryTracker.ts

@@ -3,6 +3,7 @@ import { EXCEPTION, SDK_NOT_READY } from '../utils/labels';
 import { ITelemetryTracker } from './types';
 import { timer } from '../utils/timeTracker/timer';
 import { TOKEN_REFRESH, AUTH_REJECTION } from '../utils/constants';
+import { UpdatesFromSSEEnum } from '../sync/submitters/types';
 
 export function telemetryTrackerFactory(
   telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync,
@@ -52,6 +53,9 @@ export function telemetryTrackerFactory(
       addTag(tag: string) {
         // @ts-ignore
         if (telemetryCache.addTag) telemetryCache.addTag(tag);
+      },
+      trackUpdatesFromSSE(type: UpdatesFromSSEEnum) {
+        (telemetryCache as ITelemetryCacheSync).recordUpdatesFromSSE(type);
       }
     };
 
@@ -62,7 +66,8 @@ export function telemetryTrackerFactory(
       trackHttp: noopTrack,
       sessionLength() { },
       streamingEvent() { },
-      addTag() { }
+      addTag() { },
+      trackUpdatesFromSSE() { },
     };
   }
 }

package/src/trackers/types.ts

@@ -1,5 +1,5 @@
 import { SplitIO, ImpressionDTO } from '../types';
-import { StreamingEventType, Method, OperationType } from '../sync/submitters/types';
+import { StreamingEventType, Method, OperationType, UpdatesFromSSEEnum } from '../sync/submitters/types';
 import { IEventsCacheBase } from '../storages/types';
 import { NetworkError } from '../services/types';
 
@@ -45,6 +45,10 @@ export interface ITelemetryTracker {
    * Records tag
    */
   addTag(tag: string): void
+  /**
+   * Records updates from sse
+   */
+  trackUpdatesFromSSE(type: UpdatesFromSSEEnum): void;
 }
 
 export interface IFilterAdapter {

package/types/sdkClient/types.d.ts

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-import { ImpressionDataType, EventDataType, StreamingEvent, Method, OperationType, TelemetryUsageStatsPayload } from '../../sync/submitters/types';
+import { ImpressionDataType, EventDataType, StreamingEvent, Method, OperationType, TelemetryUsageStatsPayload, UpdatesFromSSEEnum } from '../../sync/submitters/types';
 import { ISegmentsCacheSync, ISplitsCacheSync, IStorageFactoryParams, ITelemetryCacheSync } from '../types';
 export declare const MAX_LATENCY_BUCKET_COUNT = 23;
 export declare function newBuckets(): number[];
@@ -64,4 +64,10 @@ export declare class TelemetryCacheInMemory implements ITelemetryCacheSync {
     private latencies;
     popLatencies(): Partial<Record<Method, number[]>>;
     recordLatency(method: Method, latencyMs: number): void;
+    private updatesFromSSE;
+    popUpdatesFromSSE(): {
+        sp: number;
+        ms: number;
+    };
+    recordUpdatesFromSSE(type: UpdatesFromSSEEnum): void;
 }

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

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

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

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

package/types/storages/metadataBuilder.d.ts

@@ -0,0 +1,3 @@
+import { IMetadata } from '../dtos/types';
+import { ISettings } from '../types';
+export declare function metadataBuilder(settings: Pick<ISettings, 'version' | 'runtime'>): IMetadata;

package/types/storages/types.d.ts

@@ -1,5 +1,5 @@
 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 { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs, TelemetryUsageStatsPayload, UpdatesFromSSEEnum } from '../sync/submitters/types';
 import { SplitIO, ImpressionDTO, ISettings } from '../types';
 /**
  * Interface of a pluggable storage wrapper.
@@ -343,6 +343,7 @@ export interface ITelemetryRuntimeProducerSync {
     recordTokenRefreshes(): void;
     recordStreamingEvents(streamingEvent: StreamingEvent): void;
     recordSessionLength(ms: number): void;
+    recordUpdatesFromSSE(type: UpdatesFromSSEEnum): void;
 }
 export interface ITelemetryEvaluationProducerSync {
     recordLatency(method: Method, latencyMs: number): void;

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

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

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

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

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

@@ -1,7 +1,11 @@
+import { ISplit } from '../../dtos/types';
 import { IReadinessManager } from '../../readiness/types';
 import { IStorageSync } from '../../storages/types';
 import { ITask, ISyncTask } from '../types';
-export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean, till?: number], boolean> {
+export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean, till?: number, splitUpdateNotification?: {
+    payload: ISplit;
+    changeNumber: number;
+}], boolean> {
 }
 export interface ISegmentsSyncTask extends ISyncTask<[fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number], boolean> {
 }

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

@@ -4,7 +4,10 @@ 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>;
+declare type ISplitChangesUpdater = (noCache?: boolean, till?: number, splitUpdateNotification?: {
+    payload: ISplit;
+    changeNumber: number;
+}) => Promise<boolean>;
 /**
  * Collect segments from a raw split definition.
  * Exported for testing purposes.

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

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

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

@@ -1,12 +1,13 @@
 import { ILogger } from '../../../logger/types';
 import { ISplitsEventEmitter } from '../../../readiness/types';
 import { ISplitsCacheSync } from '../../../storages/types';
+import { ITelemetryTracker } from '../../../trackers/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 & {
+export declare function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker & {
     killSplit(event: ISplitKillData): 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/impressionCountsSubmitterInRedis.d.ts

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

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

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

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

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

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

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

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

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

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

@@ -90,6 +90,7 @@ 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 UpdatesFromSSEEnum = SPLITS | MY_SEGMENT;
 export declare type SPLITS = 'sp';
 export declare type IMPRESSIONS = 'im';
 export declare type IMPRESSIONS_COUNT = 'ic';
@@ -130,6 +131,10 @@ export declare type TelemetryUsageStats = {
     mL?: MethodLatencies;
     mE?: MethodExceptions;
 };
+export declare type UpdatesFromSSE = {
+    sp: number;
+    ms?: number;
+};
 export declare type TelemetryUsageStatsPayload = TelemetryUsageStats & {
     lS: LastSync;
     hE: HttpErrors;
@@ -147,6 +152,7 @@ export declare type TelemetryUsageStatsPayload = TelemetryUsageStats & {
     eD: number;
     sE: Array<StreamingEvent>;
     t?: Array<string>;
+    ufs?: UpdatesFromSSE;
 };
 /**
  * Telemetry config stats

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

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

package/types/sync/syncTaskComposite.d.ts

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

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

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

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

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

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

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

package/types/trackers/types.d.ts

@@ -1,5 +1,5 @@
 import { SplitIO, ImpressionDTO } from '../types';
-import { StreamingEventType, Method, OperationType } from '../sync/submitters/types';
+import { StreamingEventType, Method, OperationType, UpdatesFromSSEEnum } from '../sync/submitters/types';
 import { IEventsCacheBase } from '../storages/types';
 import { NetworkError } from '../services/types';
 /** Events tracker */
@@ -37,6 +37,10 @@ export interface ITelemetryTracker {
      * Records tag
      */
     addTag(tag: string): void;
+    /**
+     * Records updates from sse
+     */
+    trackUpdatesFromSSE(type: UpdatesFromSSEEnum): void;
 }
 export interface IFilterAdapter {
     add(key: string, featureName: string): boolean;

package/types/utils/timeTracker/index.d.ts

@@ -0,0 +1,70 @@
+import { ILogger } from '../../logger/types';
+import { IResponse } from '../../services/types';
+interface MetricsCollector {
+    countException(): void;
+    count(status: number): void;
+    latency(ms: number): void;
+    ready(ms: number): void;
+    getTreatment(ms: number): void;
+    getTreatments(ms: number): void;
+    getTreatmentWithConfig(ms: number): void;
+    getTreatmentsWithConfig(ms: number): void;
+    [method: string]: (ms: number) => void;
+}
+export declare const TrackerAPI: {
+    /**
+     * "Private" method, used to attach count/countException and stop callbacks to a promise.
+     *
+     * @param {ILogger} log - Logger.
+     * @param {Promise} promise - The promise we want to attach the callbacks.
+     * @param {string} task - The name of the task.
+     * @param {number | string} modifier - (optional) The modifier for the task, if any.
+     */
+    __attachToPromise(log: ILogger, promise: Promise<IResponse>, task: string, collector: false | MetricsCollector, modifier?: string | number | undefined): Promise<IResponse>;
+    /**
+     * Starts tracking the time for a given task. All tasks tracked are considered "unique" because
+     * there may be multiple SDK instances tracking a "generic" task, making any task non-generic.
+     *
+     * @param {ILogger} log - Logger.
+     * @param {string} task - The task we are starting.
+     * @param {Object} collectors - The collectors map.
+     * @param {Promise} promise - (optional) The promise we are tracking.
+     * @return {Function | Promise} The stop function for this specific task or the promise received with the callbacks registered.
+     */
+    start(log: ILogger, task: string, collectors?: Record<string, MetricsCollector> | undefined, promise?: Promise<IResponse> | undefined, now?: (() => number) | undefined): Promise<IResponse> | (() => number);
+    /**
+     * Setup the collector for a task that reports metrics.
+     *
+     * @param {string} task - The task name
+     * @param {number | string} taskUniqueId - The unique identifier for this task
+     * @param {Object} collectors - The collectors map.
+     */
+    setCollectorForTask(task: string, taskUniqueId: number | string, collectors: Record<string, MetricsCollector>): void;
+    /**
+     * Stops the tracking of a given task.
+     *
+     * @param {ILogger} log - Logger.
+     * @param {string} task - The task we are starting.
+     * @param {number | string} modifier - (optional) The modifier for that specific task.
+     */
+    stop(log: ILogger, task: string, modifier?: string | number | undefined): number | undefined;
+    /**
+     * The constants shortcut for the task names.
+     */
+    TaskNames: {
+        SDK_READY: string;
+        SDK_GET_TREATMENT: string;
+        SDK_GET_TREATMENTS: string;
+        SDK_GET_TREATMENT_WITH_CONFIG: string;
+        SDK_GET_TREATMENTS_WITH_CONFIG: string;
+        SPLITS_READY: string;
+        SEGMENTS_READY: string;
+        METRICS_PUSH: string;
+        IMPRESSIONS_PUSH: string;
+        EVENTS_PUSH: string;
+        MY_SEGMENTS_FETCH: string;
+        SEGMENTS_FETCH: string;
+        SPLITS_FETCH: string;
+    };
+};
+export {};

package/types/utils/inputValidation/sdkKey.d.ts

@@ -1,7 +0,0 @@
-import { ILogger } from '../../logger/types';
-/** validates the given SDK key */
-export declare function validateApiKey(log: ILogger, maybeSdkKey: any): string | false;
-export declare const usedKeysMap: Record<string, number>;
-/** validates the given SDK key and also warns if it is in use */
-export declare function validateAndTrackApiKey(log: ILogger, maybeSdkKey: any): string | false;
-export declare function releaseApiKey(sdkKey: string): void;