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

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;
+}

package/types/types.d.ts

@@ -1,8 +1,9 @@
 import { ISplitFiltersValidation } from './dtos/types';
 import { IIntegration, IIntegrationFactoryParams } from './integrations/types';
 import { ILogger } from './logger/types';
+import { ISdkFactoryContext } from './sdkFactory/types';
 import { IStorageFactoryParams, IStorageSync, IStorageAsync, IStorageSyncFactory, IStorageAsyncFactory } from './storages/types';
-import { ISyncManagerFactoryParams, ISyncManagerCS } from './sync/types';
+import { ISyncManagerCS } from './sync/types';
 /**
  * Reduced version of NodeJS.EventEmitter interface with the minimal methods used by the SDK
  * @see {@link https://nodejs.org/api/events.html}
@@ -73,7 +74,11 @@ export interface ISettings {
         featuresRefreshRate: number;
         impressionsRefreshRate: number;
         impressionsQueueSize: number;
-        metricsRefreshRate: number;
+        /**
+         * @deprecated
+         */
+        metricsRefreshRate?: number;
+        telemetryRefreshRate: number;
         segmentsRefreshRate: number;
         offlineRefreshRate: number;
         eventsPushRate: number;
@@ -87,12 +92,16 @@ export interface ISettings {
         eventsFirstPushWindow: number;
     };
     readonly storage: IStorageSyncFactory | IStorageAsyncFactory;
-    readonly integrations?: Array<(params: IIntegrationFactoryParams) => IIntegration | void>;
+    readonly integrations: Array<{
+        readonly type: string;
+        (params: IIntegrationFactoryParams): IIntegration | void;
+    }>;
     readonly urls: {
         events: string;
         sdk: string;
         auth: string;
         streaming: string;
+        telemetry: string;
     };
     readonly debug: boolean | LogLevel | ILogger;
     readonly version: string;
@@ -267,8 +276,15 @@ interface INodeBasicSettings extends ISharedSettings {
          * The SDK sends diagnostic metrics to Split servers. This parameters controls this metric flush period in seconds.
          * @property {number} metricsRefreshRate
          * @default 120
+         * @deprecated This parameter is ignored now.
          */
         metricsRefreshRate?: number;
+        /**
+         * The SDK sends diagnostic metrics to Split servers. This parameters controls this metric flush period in seconds.
+         * @property {number} telemetryRefreshRate
+         * @default 3600
+         */
+        telemetryRefreshRate?: number;
         /**
          * The SDK polls Split servers for changes to segment definitions. This parameter controls this polling period in seconds.
          * @property {number} segmentsRefreshRate
@@ -598,7 +614,7 @@ export declare namespace SplitIO {
      */
     type LocalhostFactory = {
         type: 'LocalhostFromObject' | 'LocalhostFromFile';
-        (params: ISyncManagerFactoryParams): ISyncManagerCS;
+        (params: ISdkFactoryContext): ISyncManagerCS;
     };
     /**
      * Impression listener interface. This is the interface that needs to be implemented
@@ -662,6 +678,12 @@ export declare namespace SplitIO {
          * @default 'https://streaming.split.io'
          */
         streaming?: string;
+        /**
+         * String property to override the base URL where the SDK will post telemetry data.
+         * @property {string} telemetry
+         * @default 'https://telemetry.split.io/api'
+         */
+        telemetry?: string;
     };
     /**
      * SplitFilter type.
@@ -791,8 +813,15 @@ export declare namespace SplitIO {
              * The SDK sends diagnostic metrics to Split servers. This parameters controls this metric flush period in seconds.
              * @property {number} metricsRefreshRate
              * @default 120
+             * @deprecated This parameter is ignored now.
              */
             metricsRefreshRate?: number;
+            /**
+             * The SDK sends diagnostic metrics to Split servers. This parameters controls this metric flush period in seconds.
+             * @property {number} telemetryRefreshRate
+             * @default 3600
+             */
+            telemetryRefreshRate?: number;
             /**
              * The SDK polls Split servers for changes to segment definitions. This parameter controls this polling period in seconds.
              * @property {number} segmentsRefreshRate

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

@@ -23,3 +23,40 @@ export declare const STORAGE_PLUGGABLE: StorageType;
 export declare const CONSENT_GRANTED = "GRANTED";
 export declare const CONSENT_DECLINED = "DECLINED";
 export declare const CONSENT_UNKNOWN = "UNKNOWN";
+export declare const QUEUED = 0;
+export declare const DROPPED = 1;
+export declare const DEDUPED = 2;
+export declare const STANDALONE_ENUM = 0;
+export declare const CONSUMER_ENUM = 1;
+export declare const CONSUMER_PARTIAL_ENUM = 2;
+export declare const OPTIMIZED_ENUM = 0;
+export declare const DEBUG_ENUM = 1;
+export declare const SPLITS = "sp";
+export declare const IMPRESSIONS = "im";
+export declare const IMPRESSIONS_COUNT = "ic";
+export declare const EVENTS = "ev";
+export declare const TELEMETRY = "te";
+export declare const TOKEN = "to";
+export declare const SEGMENT = "se";
+export declare const MY_SEGMENT = "ms";
+export declare const TREATMENT = "t";
+export declare const TREATMENTS = "ts";
+export declare const TREATMENT_WITH_CONFIG = "tc";
+export declare const TREATMENTS_WITH_CONFIG = "tcs";
+export declare const TRACK = "tr";
+export declare const CONNECTION_ESTABLISHED = 0;
+export declare const OCCUPANCY_PRI = 10;
+export declare const OCCUPANCY_SEC = 20;
+export declare const STREAMING_STATUS = 30;
+export declare const SSE_CONNECTION_ERROR = 40;
+export declare const TOKEN_REFRESH = 50;
+export declare const ABLY_ERROR = 60;
+export declare const SYNC_MODE_UPDATE = 70;
+export declare const AUTH_REJECTION = 80;
+export declare const STREAMING = 0;
+export declare const POLLING = 1;
+export declare const REQUESTED = 0;
+export declare const NON_REQUESTED = 1;
+export declare const DISABLED = 0;
+export declare const ENABLED = 1;
+export declare const PAUSED = 2;

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

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

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

@@ -1,5 +1,45 @@
 import { ISettingsValidationParams } from './types';
 import { ISettings } from '../../types';
+export declare const base: {
+    mode: import("../../types").SDKMode;
+    core: {
+        authorizationKey: undefined;
+        key: undefined;
+        trafficType: undefined;
+        labelsEnabled: boolean;
+        IPAddressesEnabled: undefined;
+    };
+    scheduler: {
+        featuresRefreshRate: number;
+        segmentsRefreshRate: number;
+        telemetryRefreshRate: number;
+        impressionsRefreshRate: number;
+        offlineRefreshRate: number;
+        eventsPushRate: number;
+        eventsQueueSize: number;
+        impressionsQueueSize: number;
+        pushRetryBackoffBase: number;
+    };
+    urls: {
+        sdk: string;
+        events: string;
+        auth: string;
+        streaming: string;
+        telemetry: string;
+    };
+    storage: undefined;
+    debug: undefined;
+    impressionListener: undefined;
+    version: undefined;
+    integrations: undefined;
+    streamingEnabled: boolean;
+    sync: {
+        splitFilters: undefined;
+        impressionsMode: string;
+        localhostMode: undefined;
+    };
+    log: undefined;
+};
 /**
  * Validates the given config and use it to build a settings object.
  * NOTE: it doesn't validate the Api Key. Call `validateApikey` or `validateAndTrackApiKey` for that after settings validation.

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

@@ -31,7 +31,7 @@ export declare const TrackerAPI: {
      * @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);
+    start(log: ILogger, task: string, collectors?: Record<string, MetricsCollector> | undefined, promise?: Promise<IResponse> | undefined, now?: () => number): Promise<IResponse> | (() => number);
     /**
      * Setup the collector for a task that reports metrics.
      *

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

@@ -1 +1 @@
-export declare function timer(now?: () => number): () => number;
+export declare function timer(now: () => number): () => number;

package/cjs/storages/inMemory/CountsCacheInMemory.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CountsCacheInMemory = void 0;
-var CountsCacheInMemory = /** @class */ (function () {
-    function CountsCacheInMemory() {
-        this.counters = {};
-    }
-    /**
-     * Add counts.
-     */
-    CountsCacheInMemory.prototype.track = function (metricName) {
-        if (this.counters[metricName] === undefined)
-            this.counters[metricName] = 1;
-        else
-            this.counters[metricName]++;
-        return true;
-    };
-    /**
-     * Clear the collector
-     */
-    CountsCacheInMemory.prototype.clear = function () {
-        this.counters = {};
-    };
-    /**
-     * Get the collected data, used as payload for posting.
-     */
-    CountsCacheInMemory.prototype.state = function () {
-        return this.counters;
-    };
-    /**
-     * Check if the cache is empty.
-     */
-    CountsCacheInMemory.prototype.isEmpty = function () {
-        return Object.keys(this.counters).length === 0;
-    };
-    return CountsCacheInMemory;
-}());
-exports.CountsCacheInMemory = CountsCacheInMemory;

package/cjs/storages/inMemory/LatenciesCacheInMemory.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LatenciesCacheInMemory = void 0;
-var findLatencyIndex_1 = require("../findLatencyIndex");
-var LatenciesCacheInMemory = /** @class */ (function () {
-    function LatenciesCacheInMemory() {
-        this.counters = {};
-    }
-    /**
-     * Add latencies.
-     */
-    LatenciesCacheInMemory.prototype.track = function (metricName, latency) {
-        // Initialize if needed
-        if (this.counters[metricName] === undefined) {
-            this.counters[metricName] = [
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-            ];
-        }
-        // +1 based on the latency number
-        this.counters[metricName][(0, findLatencyIndex_1.findLatencyIndex)(latency)]++;
-        return true;
-    };
-    /**
-     * Clear the collector
-     */
-    LatenciesCacheInMemory.prototype.clear = function () {
-        this.counters = {};
-    };
-    /**
-     * Get the collected data, used as payload for posting.
-     */
-    LatenciesCacheInMemory.prototype.state = function () {
-        return this.counters;
-    };
-    /**
-     * Check if the cache is empty.
-     */
-    LatenciesCacheInMemory.prototype.isEmpty = function () {
-        return Object.keys(this.counters).length === 0;
-    };
-    return LatenciesCacheInMemory;
-}());
-exports.LatenciesCacheInMemory = LatenciesCacheInMemory;

package/cjs/storages/inRedis/CountsCacheInRedis.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CountsCacheInRedis = void 0;
-var CountsCacheInRedis = /** @class */ (function () {
-    function CountsCacheInRedis(keys, redis) {
-        this.keys = keys;
-        this.redis = redis;
-    }
-    CountsCacheInRedis.prototype.track = function (metricName) {
-        return this.redis.incr(this.keys.buildCountKey(metricName)).catch(function () {
-            // noop, for telemetry metrics there's no need to throw.
-        }).then(function () { return true; });
-    };
-    return CountsCacheInRedis;
-}());
-exports.CountsCacheInRedis = CountsCacheInRedis;

package/cjs/storages/inRedis/LatenciesCacheInRedis.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LatenciesCacheInRedis = void 0;
-var findLatencyIndex_1 = require("../findLatencyIndex");
-var LatenciesCacheInRedis = /** @class */ (function () {
-    function LatenciesCacheInRedis(keys, redis) {
-        this.keys = keys;
-        this.redis = redis;
-    }
-    LatenciesCacheInRedis.prototype.track = function (metricName, latency) {
-        var bucketNumber = (0, findLatencyIndex_1.findLatencyIndex)(latency);
-        return this.redis.incr(this.keys.buildLatencyKey(metricName, bucketNumber)).catch(function () {
-            // noop, for telemetry metrics there's no need to throw.
-        }).then(function () { return true; });
-    };
-    return LatenciesCacheInRedis;
-}());
-exports.LatenciesCacheInRedis = LatenciesCacheInRedis;

package/cjs/sync/submitters/eventsSyncTask.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.eventsSyncTaskFactory = void 0;
-var submitterSyncTask_1 = require("./submitterSyncTask");
-var constants_1 = require("../../logger/constants");
-var DATA_NAME = 'events';
-/**
- * Sync task that periodically posts tracked events
- */
-function eventsSyncTaskFactory(log, postEventsBulk, eventsCache, eventsPushRate, eventsFirstPushWindow, latencyTracker) {
-    // don't retry events.
-    var syncTask = (0, submitterSyncTask_1.submitterSyncTaskFactory)(log, postEventsBulk, eventsCache, eventsPushRate, DATA_NAME, latencyTracker);
-    // Set a timer for the first push window of events.
-    // Not implemented in the base submitter or sync task, since this feature is only used by the events submitter.
-    if (eventsFirstPushWindow > 0) {
-        var running_1 = false;
-        var stopEventPublisherTimeout_1;
-        var originalStart_1 = syncTask.start;
-        syncTask.start = function () {
-            running_1 = true;
-            stopEventPublisherTimeout_1 = setTimeout(originalStart_1, eventsFirstPushWindow);
-        };
-        var originalStop_1 = syncTask.stop;
-        syncTask.stop = function () {
-            running_1 = false;
-            clearTimeout(stopEventPublisherTimeout_1);
-            originalStop_1();
-        };
-        syncTask.isRunning = function () {
-            return running_1;
-        };
-    }
-    // register events submitter to be executed when events cache is full
-    eventsCache.setOnFullQueueCb(function () {
-        if (syncTask.isRunning()) {
-            log.info(constants_1.SUBMITTERS_PUSH_FULL_QUEUE, [DATA_NAME]);
-            syncTask.execute();
-        }
-        // If submitter is stopped (e.g., user consent declined or unknown, or app state offline), we don't send the data.
-        // Data will be sent when submitter is resumed.
-    });
-    return syncTask;
-}
-exports.eventsSyncTaskFactory = eventsSyncTaskFactory;

package/cjs/sync/submitters/metricsSyncTask.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.latenciesSyncTaskFactory = exports.countsSyncTaskFactory = void 0;
-var lang_1 = require("../../utils/lang");
-var submitterSyncTask_1 = require("./submitterSyncTask");
-// extract POST payload object from cache
-function fromCache(propertyName) {
-    return function (data) {
-        var result = [];
-        (0, lang_1.forOwn)(data, function (value, key) {
-            var _a;
-            result.push((_a = { name: key }, _a[propertyName] = value, _a));
-        });
-        return result;
-    };
-}
-/**
- * Sync task that periodically posts telemetry counts
- */
-function countsSyncTaskFactory(log, postMetricsCounters, countsCache, metricsRefreshRate, latencyTracker) {
-    return (0, submitterSyncTask_1.submitterSyncTaskFactory)(log, postMetricsCounters, countsCache, metricsRefreshRate, 'count metrics', latencyTracker, fromCache('delta'));
-}
-exports.countsSyncTaskFactory = countsSyncTaskFactory;
-/**
- * Sync task that periodically posts telemetry latencies
- */
-function latenciesSyncTaskFactory(log, postMetricsLatencies, latenciesCache, metricsRefreshRate, latencyTracker) {
-    // don't retry metrics.
-    return (0, submitterSyncTask_1.submitterSyncTaskFactory)(log, postMetricsLatencies, latenciesCache, metricsRefreshRate, 'latency metrics', latencyTracker, fromCache('latencies'), 0, true);
-}
-exports.latenciesSyncTaskFactory = latenciesSyncTaskFactory;