@splitsoftware/splitio-commons 1.7.3-rc.0 → 1.8.0

package/CHANGES.txt

@@ -1,7 +1,10 @@
+1.8.0 (February 3, 2023)
+- Added flush data method to client
+
 1.7.3 (December 16, 2022)
-- Updated events and impressions cache in localhost mode in order to avoid memory leaks (Related to issue https://github.com/splitio/javascript-commons/issues/181).
 - Updated unique keys cache for Redis and Pluggable storages to optimize the usage of the underlying storage.
 - Updated some transitive dependencies for vulnerability fixes.
+- Bugfixing - Updated events and impressions cache in localhost mode in order to avoid memory leaks (Related to issue https://github.com/splitio/javascript-commons/issues/181).
 
 1.7.2 (October 14, 2022)
 - Bugfixing - Handle `Navigator.sendBeacon` API exceptions in the browser, and fallback to regular Fetch/XHR transport in case of error.

package/LICENSE

@@ -1,4 +1,4 @@
-Copyright © 2022 Split Software, Inc.
+Copyright © 2023 Split Software, Inc.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

package/cjs/sdkClient/sdkClient.js

@@ -5,11 +5,32 @@ var objectAssign_1 = require("../utils/lang/objectAssign");
 var apiKey_1 = require("../utils/inputValidation/apiKey");
 var client_1 = require("./client");
 var clientInputValidation_1 = require("./clientInputValidation");
+var COOLDOWN_TIME_IN_MILLIS = 1000;
 /**
  * Creates an Sdk client, i.e., a base client with status and destroy interface
  */
 function sdkClientFactory(params, isSharedClient) {
     var sdkReadinessManager = params.sdkReadinessManager, syncManager = params.syncManager, storage = params.storage, signalListener = params.signalListener, settings = params.settings, telemetryTracker = params.telemetryTracker, uniqueKeysTracker = params.uniqueKeysTracker;
+    var lastActionTime = 0;
+    function __cooldown(func, time) {
+        var now = Date.now();
+        //get the actual time elapsed in ms
+        var timeElapsed = now - lastActionTime;
+        //check if the time elapsed is less than desired cooldown
+        if (timeElapsed < time) {
+            //if yes, return message with remaining time in seconds
+            settings.log.warn("Flush cooldown, remaining time " + (time - timeElapsed) / 1000 + " seconds");
+            return Promise.resolve();
+        }
+        else {
+            //Do the requested action and re-assign the lastActionTime
+            lastActionTime = now;
+            return func();
+        }
+    }
+    function __flush() {
+        return syncManager ? syncManager.flush() : Promise.resolve();
+    }
     return (0, objectAssign_1.objectAssign)(
     // Proto-linkage of the readiness Event Emitter
     Object.create(sdkReadinessManager.sdkStatus), 
@@ -17,14 +38,17 @@ function sdkClientFactory(params, isSharedClient) {
     (0, clientInputValidation_1.clientInputValidationDecorator)(settings, (0, client_1.clientFactory)(params), sdkReadinessManager.readinessManager), 
     // Sdk destroy
     {
+        flush: function () {
+            // @TODO define cooldown time
+            return __cooldown(__flush, COOLDOWN_TIME_IN_MILLIS);
+        },
         destroy: function () {
             // record stat before flushing data
             if (!isSharedClient)
                 telemetryTracker.sessionLength();
             // Stop background jobs
             syncManager && syncManager.stop();
-            var flush = syncManager ? syncManager.flush() : Promise.resolve();
-            return flush.then(function () {
+            return __flush().then(function () {
                 // Cleanup event listeners
                 sdkReadinessManager.readinessManager.destroy();
                 signalListener && signalListener.stop();

package/esm/sdkClient/sdkClient.js

@@ -2,11 +2,32 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { releaseApiKey } from '../utils/inputValidation/apiKey';
 import { clientFactory } from './client';
 import { clientInputValidationDecorator } from './clientInputValidation';
+var COOLDOWN_TIME_IN_MILLIS = 1000;
 /**
  * Creates an Sdk client, i.e., a base client with status and destroy interface
  */
 export function sdkClientFactory(params, isSharedClient) {
     var sdkReadinessManager = params.sdkReadinessManager, syncManager = params.syncManager, storage = params.storage, signalListener = params.signalListener, settings = params.settings, telemetryTracker = params.telemetryTracker, uniqueKeysTracker = params.uniqueKeysTracker;
+    var lastActionTime = 0;
+    function __cooldown(func, time) {
+        var now = Date.now();
+        //get the actual time elapsed in ms
+        var timeElapsed = now - lastActionTime;
+        //check if the time elapsed is less than desired cooldown
+        if (timeElapsed < time) {
+            //if yes, return message with remaining time in seconds
+            settings.log.warn("Flush cooldown, remaining time " + (time - timeElapsed) / 1000 + " seconds");
+            return Promise.resolve();
+        }
+        else {
+            //Do the requested action and re-assign the lastActionTime
+            lastActionTime = now;
+            return func();
+        }
+    }
+    function __flush() {
+        return syncManager ? syncManager.flush() : Promise.resolve();
+    }
     return objectAssign(
     // Proto-linkage of the readiness Event Emitter
     Object.create(sdkReadinessManager.sdkStatus), 
@@ -14,14 +35,17 @@ export function sdkClientFactory(params, isSharedClient) {
     clientInputValidationDecorator(settings, clientFactory(params), sdkReadinessManager.readinessManager), 
     // Sdk destroy
     {
+        flush: function () {
+            // @TODO define cooldown time
+            return __cooldown(__flush, COOLDOWN_TIME_IN_MILLIS);
+        },
         destroy: function () {
             // record stat before flushing data
             if (!isSharedClient)
                 telemetryTracker.sessionLength();
             // Stop background jobs
             syncManager && syncManager.stop();
-            var flush = syncManager ? syncManager.flush() : Promise.resolve();
-            return flush.then(function () {
+            return __flush().then(function () {
                 // Cleanup event listeners
                 sdkReadinessManager.readinessManager.destroy();
                 signalListener && signalListener.stop();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.7.3-rc.0",
+  "version": "1.8.0",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/sdkClient/sdkClient.ts

@@ -5,12 +5,36 @@ import { clientFactory } from './client';
 import { clientInputValidationDecorator } from './clientInputValidation';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 
+const COOLDOWN_TIME_IN_MILLIS = 1000;
+
 /**
  * Creates an Sdk client, i.e., a base client with status and destroy interface
  */
 export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: boolean): SplitIO.IClient | SplitIO.IAsyncClient {
   const { sdkReadinessManager, syncManager, storage, signalListener, settings, telemetryTracker, uniqueKeysTracker } = params;
 
+  let lastActionTime = 0;
+
+  function __cooldown(func: Function, time: number) {
+    const now = Date.now();
+    //get the actual time elapsed in ms
+    const timeElapsed = now - lastActionTime;
+    //check if the time elapsed is less than desired cooldown
+    if (timeElapsed < time){
+      //if yes, return message with remaining time in seconds
+      settings.log.warn(`Flush cooldown, remaining time ${(time-timeElapsed)/1000} seconds`);
+      return Promise.resolve();
+    } else {
+      //Do the requested action and re-assign the lastActionTime
+      lastActionTime = now;
+      return func();
+    }
+  }
+
+  function __flush() {
+    return syncManager ? syncManager.flush() : Promise.resolve();
+  }
+
   return objectAssign(
     // Proto-linkage of the readiness Event Emitter
     Object.create(sdkReadinessManager.sdkStatus) as IStatusInterface,
@@ -24,15 +48,18 @@ export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: bo
 
     // Sdk destroy
     {
+      flush() {
+        // @TODO define cooldown time
+        return __cooldown(__flush, COOLDOWN_TIME_IN_MILLIS);
+      },
       destroy() {
         // record stat before flushing data
         if (!isSharedClient) telemetryTracker.sessionLength();
 
         // Stop background jobs
         syncManager && syncManager.stop();
-        const flush = syncManager ? syncManager.flush() : Promise.resolve();
 
-        return flush.then(() => {
+        return __flush().then(() => {
           // Cleanup event listeners
           sdkReadinessManager.readinessManager.destroy();
           signalListener && signalListener.stop();

package/src/types.ts

@@ -411,6 +411,12 @@ export interface IStatusInterface extends IEventEmitter {
  * @extends IStatusInterface
  */
 interface IBasicClient extends IStatusInterface {
+  /**
+   * Flush data
+   * @function flush
+   * @return {Promise<void>}
+   */
+  flush(): Promise<void>
   /**
    * Destroy the client instance.
    * @function destroy

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

@@ -405,6 +405,12 @@ export interface IStatusInterface extends IEventEmitter {
  * @extends IStatusInterface
  */
 interface IBasicClient extends IStatusInterface {
+    /**
+     * Flush data
+     * @function flush
+     * @return {Promise<void>}
+     */
+    flush(): Promise<void>;
     /**
      * Destroy the client instance.
      * @function destroy

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