@splitsoftware/splitio 10.17.3-rc.3 → 10.17.3-rc.4

package/src/utils/settings/storage/browser.js

@@ -0,0 +1,70 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+
+import logFactory from '../../../utils/logger';
+const log = logFactory('splitio-settings');
+import isLocalStorageAvailable from '../../../utils/localstorage/isAvailable';
+import {
+  LOCALHOST_MODE,
+  STORAGE_MEMORY,
+  STORAGE_LOCALSTORAGE
+} from '../../../utils/constants';
+
+const ParseStorageSettings = settings => {
+  let {
+    mode,
+    storage: {
+      type = STORAGE_MEMORY,
+      options = {},
+      prefix
+    },
+  } = settings;
+  let __originalType;
+
+  if (prefix) {
+    prefix += '.SPLITIO';
+  } else {
+    prefix = 'SPLITIO';
+  }
+
+  const fallbackToMemory = () => {
+    __originalType = type;
+    type = STORAGE_MEMORY;
+  };
+
+  // In localhost mode, fallback to Memory storage and track original
+  // type to emit SDK_READY_FROM_CACHE if corresponds
+  if (mode === LOCALHOST_MODE && type === STORAGE_LOCALSTORAGE) {
+    fallbackToMemory();
+  }
+
+  // If an invalid storage type is provided OR we want to use LOCALSTORAGE and
+  // it's not available, fallback into MEMORY
+  if (type !== STORAGE_MEMORY && type !== STORAGE_LOCALSTORAGE ||
+    type === STORAGE_LOCALSTORAGE && !isLocalStorageAvailable()) {
+    fallbackToMemory();
+    log.warn('Invalid or unavailable storage. Fallbacking into MEMORY storage');
+  }
+
+  return {
+    type,
+    options,
+    prefix,
+    __originalType
+  };
+};
+
+export default ParseStorageSettings;

package/src/{settings → utils/settings}/storage/node.js

@@ -1,14 +1,28 @@
-import { LOCALHOST_MODE, STORAGE_MEMORY, STORAGE_REDIS, CONSUMER_MODE, STANDALONE_MODE } from '@splitsoftware/splitio-commons/src/utils/constants';
+/**
+Copyright 2016 Split Software
 
-export function validateStorage(settings) {
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+import { LOCALHOST_MODE, STORAGE_MEMORY, STORAGE_REDIS } from '../../constants';
+
+const ParseStorageSettings = (settings) => {
   let {
-    log,
     mode,
     storage: {
       type,
       options = {},
       prefix
-    } = { type: STORAGE_MEMORY }
+    }
   } = settings;
 
   if (prefix) {
@@ -17,17 +31,15 @@ export function validateStorage(settings) {
     prefix = 'SPLITIO';
   }
 
-  // We can have MEMORY, REDIS or an invalid storage type
+  // In localhost mode we should force the user to use the MEMORY storage
+  if (mode === LOCALHOST_MODE) return {
+    type: STORAGE_MEMORY,
+    prefix
+  };
+
+  // In other cases we can have MEMORY or REDIS
   switch (type) {
     case STORAGE_REDIS: {
-      // If passing REDIS storage in localhost or standalone mode, we log an error and fallback to MEMORY storage
-      if (mode === STANDALONE_MODE || mode === LOCALHOST_MODE) {
-        log.error('The provided REDIS storage is invalid for this mode. It requires consumer mode. Fallbacking into default MEMORY storage.');
-        return {
-          type: STORAGE_MEMORY,
-          prefix
-        };
-      }
       let {
         host,
         port,
@@ -72,14 +84,12 @@ export function validateStorage(settings) {
     // For now, we don't have modifiers or settings for MEMORY in NodeJS
     case STORAGE_MEMORY:
     default: {
-      // If passing MEMORY storage in consumer mode, throw an error (no way to fallback to REDIS storage)
-      if (mode === CONSUMER_MODE) throw new Error('A REDIS storage is required on consumer mode');
-      // If passing an invalid storage type, log an error
-      if (type !== STORAGE_MEMORY) log.error(`The provided '${type}' storage type is invalid. Fallbacking into default MEMORY storage.`);
       return {
         type: STORAGE_MEMORY,
         prefix
       };
     }
   }
-}
+};
+
+export default ParseStorageSettings;

package/src/utils/settings/storage/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "./node.js",
+  "browser": "./browser.js"
+}

package/src/utils/splits/usesSegments.js

@@ -0,0 +1,17 @@
+/**
+ * Given a list of conditions, it returns a boolean flagging if those conditions 
+ * use segments matchers (rules & whitelists)
+ */
+function usesSegments(conditions = []) {
+  for (let i = 0; i < conditions.length; i++) {
+    const matchers = conditions[i].matcherGroup.matchers;
+
+    for (let j = 0; j < matchers.length; j++) {
+      if (matchers[j].matcherType === 'IN_SEGMENT') return true;
+    }
+  }
+
+  return false;
+}
+
+export default usesSegments;

package/src/utils/time/index.js

@@ -0,0 +1,8 @@
+const DEDUP_WINDOW_SIZE_MS = 3600*1000;
+
+/**
+* Truncates de time frame received with the time window.
+*/
+export function truncateTimeFrame(timestampInMs) {
+  return timestampInMs - (timestampInMs % DEDUP_WINDOW_SIZE_MS);
+}

package/src/utils/timeTracker/index.js

@@ -0,0 +1,223 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+
+import { uniqueId } from '../lang';
+import { Logger } from '../logger/LoggerFactory';
+import timer from './timer';
+import thenable from '../promise/thenable';
+
+// logger to be used on this module
+const logger = new Logger('[TIME TRACKER]', {
+  showLevel: false
+});
+
+// Map we will use for storing timers data
+const timers = {};
+// Tasks constants
+const CONSTANTS = {
+  SDK_READY: 'Getting ready - Split SDK',
+  SDK_GET_TREATMENT: 'SDK - Get Treatment',
+  SDK_GET_TREATMENTS: 'SDK - Get Treatments',
+  SDK_GET_TREATMENT_WITH_CONFIG: 'SDK - Get Treatment with config',
+  SDK_GET_TREATMENTS_WITH_CONFIG: 'SDK - Get Treatments with config',
+  SPLITS_READY: 'Getting ready - Splits',
+  SEGMENTS_READY: 'Getting ready - Segments',
+  METRICS_PUSH: 'Pushing - Metrics',
+  IMPRESSIONS_PUSH: 'Pushing - Impressions',
+  EVENTS_PUSH: 'Pushing - Events',
+  MY_SEGMENTS_FETCH: 'Fetching - My Segments',
+  SEGMENTS_FETCH: 'Fetching - Segments',
+  SPLITS_FETCH: 'Fetching - Splits'
+};
+// Tasks callbacks, if any
+const CALLBACKS = {
+  [CONSTANTS.SDK_READY]: {
+    collector: 'client',
+    method: 'ready'
+  },
+  [CONSTANTS.SDK_GET_TREATMENT]: {
+    collector: 'client',
+    method: 'getTreatment'
+  },
+  [CONSTANTS.SDK_GET_TREATMENTS]: {
+    collector: 'client',
+    method: 'getTreatments'
+  },
+  [CONSTANTS.SDK_GET_TREATMENT_WITH_CONFIG]: {
+    collector: 'client',
+    method: 'getTreatmentWithConfig'
+  },
+  [CONSTANTS.SDK_GET_TREATMENTS_WITH_CONFIG]: {
+    collector: 'client',
+    method: 'getTreatmentsWithConfig'
+  },
+  [CONSTANTS.MY_SEGMENTS_FETCH]: {
+    collector: 'mySegments',
+    method: 'latency'
+  },
+  [CONSTANTS.SEGMENTS_FETCH]: {
+    collector: 'segmentChanges',
+    method: 'latency'
+  },
+  [CONSTANTS.SPLITS_FETCH]: {
+    collector: 'splitChanges',
+    method: 'latency'
+  }
+};
+/**
+ * Generates the timer keys using the task name and a modifier, if any.
+ * @param {string} task - The task name
+ * @param {string} modifier - (optional) The modifier, if any.
+ * @return {string} The generated timer key
+ */
+const generateTimerKey = (task, modifier) => typeof modifier === 'string' ? task + modifier : task;
+/**
+ * Given the collectors map, it returns the specific collector for a given task.
+ *
+ * @param {string} task - The task name
+ * @param {Object} collectors - The collectors map
+ */
+const getCollectorForTask = (task, collectors) => {
+  const callbackData = CALLBACKS[task];
+
+  if (callbackData && collectors) return collectors[callbackData.collector];
+
+  return false;
+};
+/**
+ * Given a collector and a task, returns the callback function that should be called when we stop the timer.
+ *
+ * @param {string} task - The task name
+ * @param {Object} collector - The collector object for the task
+ */
+const getCallbackForTask = (task, collector) => {
+  const callbackData = CALLBACKS[task];
+
+  if (callbackData && collector) return collector[callbackData.method];
+
+  return false;
+};
+
+const TrackerAPI = {
+  /**
+   * "Private" method, used to attach count/countException and stop callbacks to a promise.
+   *
+   * @param {Promise} promise - The promise we want to attach the callbacks.
+   * @param {string} task - The name of the task.
+   * @param {string} modifier - (optional) The modifier for the task, if any.
+   */
+  __attachToPromise(promise, task, collector, modifier) {
+    return promise.then(resp => {
+      this.stop(task, modifier);
+
+      if (collector && collector.count) collector.count(resp.status);
+
+      return resp;
+    })
+      .catch(err => {
+        this.stop(task, modifier);
+
+        if (collector && collector.countException) collector.countException();
+
+        throw err;
+      });
+  },
+  /**
+   * 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 {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(task, collectors, promise) {
+    const taskUniqueId = uniqueId();
+    const taskCollector = getCollectorForTask(task, collectors);
+    let result;
+
+    // If we are registering a promise with this task, we should count the status and the exceptions as well
+    // as stopping the task when the promise resolves. Then return the promise
+    if (thenable(promise)) {
+      result = this.__attachToPromise(promise, task, taskCollector, taskUniqueId);
+    } else {
+      // If not, we return the stop function, as it will be stopped manually.
+      result = this.stop.bind(this, task, taskUniqueId);
+      if (CALLBACKS[task] && !taskCollector) {
+        // and provide a way for a defered setup of the collector, if needed.
+        result.setCollectorForTask = this.setCollectorForTask.bind(this, task, taskUniqueId);
+      }
+    }
+
+    // We start the timer, with an uniqueId attached to it's name, and save tracking info for this task.
+    const trackingKey = generateTimerKey(task, taskUniqueId);
+    const cb = getCallbackForTask(task, taskCollector);
+    timers[trackingKey] = {
+      cb,
+      timer: timer()
+    };
+
+    return result;
+  },
+  /**
+   * Setup the collector for a task that reports metrics.
+   *
+   * @param {string} task - The task name
+   * @param {string} taskUniqueId - The unique identifier for this task
+   * @param {Object} collectors - The collectors map.
+   */
+  setCollectorForTask(task, taskUniqueId, collectors) {
+    const taskCollector = getCollectorForTask(task, collectors);
+
+    if (taskCollector) {
+      const trackingKey = generateTimerKey(task, taskUniqueId);
+      timers[trackingKey].cb = getCallbackForTask(task, taskCollector);
+    }
+  },
+  /**
+   * Stops the tracking of a given task.
+   *
+   * @param {string} task - The task we are starting.
+   * @param {string} modifier - (optional) The modifier for that specific task.
+   */
+  stop(task, modifier) {
+    const timerName = generateTimerKey(task, modifier);
+    const timerData = timers[timerName];
+    if (timerData) {
+      // Stop the timer and round result for readability.
+      const et = timerData.timer();
+      logger.debug(`[${task}] took ${et}ms to finish.`);
+
+      // Check if we have a tracker callback.
+      if (timerData.cb) {
+        // If we have a callback, we call it with the elapsed time of the task and then delete the reference.
+        timerData.cb(et);
+      }
+
+      // Remove the task tracking reference.
+      delete timers[timerName];
+
+      return et;
+    }
+  },
+  /**
+   * The constants shortcut for the task names.
+   */
+  TaskNames: CONSTANTS
+};
+
+// Our "time tracker" API
+export default TrackerAPI;

package/src/utils/timeTracker/timer.js

@@ -0,0 +1,27 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+
+import now from '../now';
+
+function start() {
+  const st = now();
+
+  return function stop() {
+    return Math.round( now() - st );
+  };
+}
+
+export default start;

package/types/splitio.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Javascript and Node Split Software SDK
+// Type definitions for Javascript and Node Split Software SDK v8.1.0
 // Project: http://www.split.io/
 // Definitions by: Nico Zelaya <https://github.com/NicoZelaya/>
 
@@ -336,8 +336,7 @@ interface INodeBasicSettings extends ISharedSettings {
     prefix?: string
   },
   /**
-   * The SDK mode. Possible values are "standalone", which is the default when using a synchronous storage, like 'MEMORY' and 'LOCALSTORAGE',
-   * and "consumer", which must be set when using an asynchronous storage, like 'REDIS'. For "localhost" mode, use "localhost" as authorizationKey.
+   * The SDK mode. Possible values are "standalone" (which is the default) and "consumer". For "localhost" mode, use "localhost" as authorizationKey.
    * @property {SDKMode} mode
    * @default standalone
    */
@@ -1021,15 +1020,7 @@ declare namespace SplitIO {
        * @default SPLITIO
        */
       prefix?: string
-    },
-    /**
-     * The SDK mode. When using the default 'MEMORY' storage, the only possible value is "standalone", which is the default.
-     * For "localhost" mode, use "localhost" as authorizationKey.
-     *
-     * @property {'standalone'} mode
-     * @default standalone
-     */
-    mode?: 'standalone'
+    }
   }
   /**
    * Settings interface with async storage for SDK instances created on NodeJS.
@@ -1041,7 +1032,7 @@ declare namespace SplitIO {
   interface INodeAsyncSettings extends INodeBasicSettings {
     storage: {
       /**
-       * 'REDIS' storage type to be instantiated by the SDK.
+       * Redis storage type to be instantiated by the SDK.
        * @property {NodeAsyncStorage} type
        */
       type: NodeAsyncStorage,
@@ -1056,15 +1047,7 @@ declare namespace SplitIO {
        * @default SPLITIO
        */
       prefix?: string
-    },
-    /**
-     * The SDK mode. When using 'REDIS' storage type, the only possible value is "consumer", which is required.
-     *
-     * @see {@link https://help.split.io/hc/en-us/articles/360020564931-Node-js-SDK#state-sharing-redis-integration}
-     *
-     * @property {'consumer'} mode
-     */
-    mode: 'consumer'
+    }
   }
   /**
    * This represents the interface for the SDK instance with synchronous storage.

package/client/package.json

@@ -1,5 +0,0 @@
-{
-  "main": "../lib/factory/browser.js",
-  "module": "../es/factory/browser.js",
-  "types": "../types/client/index.d.ts"
-}

package/es/factory/browser.js

@@ -1,66 +0,0 @@
-import { splitApiFactory } from '@splitsoftware/splitio-commons/esm/services/splitApi';
-import { syncManagerOnlineFactory } from '@splitsoftware/splitio-commons/esm/sync/syncManagerOnline';
-import { pushManagerFactory } from '@splitsoftware/splitio-commons/esm/sync/streaming/pushManager';
-import { pollingManagerCSFactory } from '@splitsoftware/splitio-commons/esm/sync/polling/pollingManagerCS';
-import { InLocalStorage } from '@splitsoftware/splitio-commons/esm/storages/inLocalStorage';
-import { InMemoryStorageCSFactory } from '@splitsoftware/splitio-commons/esm/storages/inMemory/InMemoryStorageCS';
-import { sdkManagerFactory } from '@splitsoftware/splitio-commons/esm/sdkManager';
-import { sdkClientMethodCSFactory } from '@splitsoftware/splitio-commons/esm/sdkClient/sdkClientMethodCSWithTT';
-import { impressionObserverCSFactory } from '@splitsoftware/splitio-commons/esm/trackers/impressionObserver/impressionObserverCS';
-import { integrationsManagerFactory } from '@splitsoftware/splitio-commons/esm/integrations/browser';
-import { __InLocalStorageMockFactory } from '@splitsoftware/splitio-commons/esm/utils/settingsValidation/storage/storageCS';
-import { sdkFactory } from '@splitsoftware/splitio-commons/esm/sdkFactory';
-import { LOCALHOST_MODE, STORAGE_LOCALSTORAGE } from '@splitsoftware/splitio-commons/esm/utils/constants';
-import { shouldAddPt } from '@splitsoftware/splitio-commons/esm/trackers/impressionObserver/utils';
-import { settingsFactory } from '../settings/browser';
-import { platform, SignalListener } from '../platform';
-var syncManagerOnlineCSFactory = syncManagerOnlineFactory(pollingManagerCSFactory, pushManagerFactory);
-function getStorage(settings) {
-    return settings.storage.type === STORAGE_LOCALSTORAGE ?
-        InLocalStorage(settings.storage)
-        : settings.storage.__originalType === STORAGE_LOCALSTORAGE ?
-            __InLocalStorageMockFactory
-            : InMemoryStorageCSFactory;
-}
-/**
- *
- * @param {import("@splitsoftware/splitio-commons/types/types").ISettings} settings
- */
-function getModules(settings) {
-    var modules = {
-        settings: settings,
-        platform: platform,
-        storageFactory: getStorage(settings),
-        splitApiFactory: splitApiFactory,
-        syncManagerFactory: syncManagerOnlineCSFactory,
-        sdkManagerFactory: sdkManagerFactory,
-        sdkClientMethodFactory: sdkClientMethodCSFactory,
-        SignalListener: SignalListener,
-        impressionListener: settings.impressionListener,
-        integrationsManagerFactory: settings.integrations && settings.integrations.length > 0 ? integrationsManagerFactory.bind(null, settings.integrations) : undefined,
-        impressionsObserverFactory: shouldAddPt(settings) ? impressionObserverCSFactory : undefined,
-    };
-    switch (settings.mode) {
-        case LOCALHOST_MODE:
-            modules.splitApiFactory = undefined;
-            modules.syncManagerFactory = settings.sync.localhostMode;
-            modules.SignalListener = undefined;
-            break;
-    }
-    return modules;
-}
-/**
- * SplitFactory for client-side.
- *
- * @param {SplitIO.IBrowserSettings} config configuration object used to instantiate the SDK
- * @param {Function=} __updateModules optional function that lets redefine internal SDK modules. Use with
- * caution since, unlike `config`, this param is not validated neither considered part of the public API.
- * @throws Will throw an error if the provided config is invalid.
- */
-export function SplitFactory(config, __updateModules) {
-    var settings = settingsFactory(config);
-    var modules = getModules(settings);
-    if (__updateModules)
-        __updateModules(modules);
-    return sdkFactory(modules);
-}

package/es/factory/node.js

@@ -1,64 +0,0 @@
-import { splitApiFactory } from '@splitsoftware/splitio-commons/esm/services/splitApi';
-import { syncManagerOnlineFactory } from '@splitsoftware/splitio-commons/esm/sync/syncManagerOnline';
-import { pushManagerFactory } from '@splitsoftware/splitio-commons/esm/sync/streaming/pushManager';
-import { pollingManagerSSFactory } from '@splitsoftware/splitio-commons/esm/sync/polling/pollingManagerSS';
-import { InRedisStorage } from '@splitsoftware/splitio-commons/esm/storages/inRedis';
-import { InMemoryStorageFactory } from '@splitsoftware/splitio-commons/esm/storages/inMemory/InMemoryStorage';
-import { sdkManagerFactory } from '@splitsoftware/splitio-commons/esm/sdkManager';
-import { sdkClientMethodFactory } from '@splitsoftware/splitio-commons/esm/sdkClient/sdkClientMethod';
-import { impressionObserverSSFactory } from '@splitsoftware/splitio-commons/esm/trackers/impressionObserver/impressionObserverSS';
-import { sdkFactory } from '@splitsoftware/splitio-commons/esm/sdkFactory';
-import { CONSUMER_MODE, LOCALHOST_MODE } from '@splitsoftware/splitio-commons/esm/utils/constants';
-import { shouldAddPt } from '@splitsoftware/splitio-commons/esm/trackers/impressionObserver/utils';
-import { settingsFactory } from '../settings/node';
-import { platform, SignalListener } from '../platform';
-var syncManagerOnlineSSFactory = syncManagerOnlineFactory(pollingManagerSSFactory, pushManagerFactory);
-function getStorage(settings) {
-    return settings.storage.type === 'REDIS' ?
-        InRedisStorage(settings.storage) :
-        InMemoryStorageFactory;
-}
-/**
- *
- * @param {import("@splitsoftware/splitio-commons/types/types").ISettings} settings
- */
-function getModules(settings) {
-    var modules = {
-        settings: settings,
-        platform: platform,
-        storageFactory: getStorage(settings),
-        splitApiFactory: splitApiFactory,
-        syncManagerFactory: syncManagerOnlineSSFactory,
-        sdkManagerFactory: sdkManagerFactory,
-        sdkClientMethodFactory: sdkClientMethodFactory,
-        SignalListener: SignalListener,
-        impressionListener: settings.impressionListener,
-        impressionsObserverFactory: shouldAddPt(settings) ? impressionObserverSSFactory : undefined,
-    };
-    switch (settings.mode) {
-        case LOCALHOST_MODE:
-            modules.splitApiFactory = undefined;
-            modules.syncManagerFactory = settings.sync.localhostMode;
-            modules.SignalListener = undefined;
-            break;
-        case CONSUMER_MODE:
-            modules.syncManagerFactory = undefined;
-            break;
-    }
-    return modules;
-}
-/**
- * SplitFactory for server-side.
- *
- * @param {SplitIO.INodeSettings | SplitIO.INodeAsyncSettings} config configuration object used to instantiate the SDK
- * @param {Function=} __updateModules optional function that lets redefine internal SDK modules. Use with
- * caution since, unlike `config`, this param is not validated neither considered part of the public API.
- * @throws Will throw an error if the provided config is invalid.
- */
-export function SplitFactory(config, __updateModules) {
-    var settings = settingsFactory(config);
-    var modules = getModules(settings);
-    if (__updateModules)
-        __updateModules(modules);
-    return sdkFactory(modules);
-}