@splitsoftware/splitio 10.17.3-rc.2 → 10.17.3

package/lib/utils/timeTracker/index.js

@@ -0,0 +1,213 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _lang = require("../lang");
+
+var _LoggerFactory = require("../logger/LoggerFactory");
+
+var _timer = _interopRequireDefault(require("./timer"));
+
+var _thenable = _interopRequireDefault(require("../promise/thenable"));
+
+var _CALLBACKS;
+
+// logger to be used on this module
+var logger = new _LoggerFactory.Logger('[TIME TRACKER]', {
+  showLevel: false
+}); // Map we will use for storing timers data
+
+var timers = {}; // Tasks constants
+
+var 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
+
+var CALLBACKS = (_CALLBACKS = {}, _CALLBACKS[CONSTANTS.SDK_READY] = {
+  collector: 'client',
+  method: 'ready'
+}, _CALLBACKS[CONSTANTS.SDK_GET_TREATMENT] = {
+  collector: 'client',
+  method: 'getTreatment'
+}, _CALLBACKS[CONSTANTS.SDK_GET_TREATMENTS] = {
+  collector: 'client',
+  method: 'getTreatments'
+}, _CALLBACKS[CONSTANTS.SDK_GET_TREATMENT_WITH_CONFIG] = {
+  collector: 'client',
+  method: 'getTreatmentWithConfig'
+}, _CALLBACKS[CONSTANTS.SDK_GET_TREATMENTS_WITH_CONFIG] = {
+  collector: 'client',
+  method: 'getTreatmentsWithConfig'
+}, _CALLBACKS[CONSTANTS.MY_SEGMENTS_FETCH] = {
+  collector: 'mySegments',
+  method: 'latency'
+}, _CALLBACKS[CONSTANTS.SEGMENTS_FETCH] = {
+  collector: 'segmentChanges',
+  method: 'latency'
+}, _CALLBACKS[CONSTANTS.SPLITS_FETCH] = {
+  collector: 'splitChanges',
+  method: 'latency'
+}, _CALLBACKS);
+/**
+ * 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
+ */
+
+var generateTimerKey = function generateTimerKey(task, modifier) {
+  return 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
+ */
+
+
+var getCollectorForTask = function getCollectorForTask(task, collectors) {
+  var 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
+ */
+
+
+var getCallbackForTask = function getCallbackForTask(task, collector) {
+  var callbackData = CALLBACKS[task];
+  if (callbackData && collector) return collector[callbackData.method];
+  return false;
+};
+
+var 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: function __attachToPromise(promise, task, collector, modifier) {
+    var _this = this;
+
+    return promise.then(function (resp) {
+      _this.stop(task, modifier);
+
+      if (collector && collector.count) collector.count(resp.status);
+      return resp;
+    }).catch(function (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: function start(task, collectors, promise) {
+    var taskUniqueId = (0, _lang.uniqueId)();
+    var taskCollector = getCollectorForTask(task, collectors);
+    var 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 ((0, _thenable.default)(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.
+
+
+    var trackingKey = generateTimerKey(task, taskUniqueId);
+    var cb = getCallbackForTask(task, taskCollector);
+    timers[trackingKey] = {
+      cb: cb,
+      timer: (0, _timer.default)()
+    };
+    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: function setCollectorForTask(task, taskUniqueId, collectors) {
+    var taskCollector = getCollectorForTask(task, collectors);
+
+    if (taskCollector) {
+      var 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: function stop(task, modifier) {
+    var timerName = generateTimerKey(task, modifier);
+    var timerData = timers[timerName];
+
+    if (timerData) {
+      // Stop the timer and round result for readability.
+      var 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
+
+var _default = TrackerAPI;
+exports.default = _default;

package/lib/utils/timeTracker/timer.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _now = _interopRequireDefault(require("../now"));
+
+/**
+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.
+**/
+function start() {
+  var st = (0, _now.default)();
+  return function stop() {
+    return Math.round((0, _now.default)() - st);
+  };
+}
+
+var _default = start;
+exports.default = _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio",
-  "version": "10.17.3-rc.2",
+  "version": "10.17.3",
   "description": "Split SDK",
   "files": [
     "README.md",
@@ -8,11 +8,9 @@
     "LICENSE",
     "CHANGES.txt",
     "lib",
-    "types",
+    "types/*.d.ts",
     "es",
-    "src",
-    "client",
-    "server"
+    "src"
   ],
   "repository": "splitio/javascript-client",
   "homepage": "https://github.com/splitio/javascript-client#readme",
@@ -35,12 +33,13 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.13.10",
-    "@splitsoftware/splitio-commons": "1.2.1-rc.0",
     "@types/google.analytics": "0.0.40",
+    "events": "3.1.0",
     "ioredis": "^4.28.0",
     "ip": "1.1.5",
     "js-yaml": "3.13.1",
     "node-fetch": "^2.6.7",
+    "object-assign": "^4.1.1",
     "unfetch": "^4.2.0"
   },
   "optionalDependencies": {
@@ -49,10 +48,8 @@
   "devDependencies": {
     "@babel/cli": "^7.15.7",
     "@babel/core": "^7.13.10",
-    "@babel/plugin-proposal-class-properties": "^7.16.7",
     "@babel/plugin-transform-runtime": "^7.13.10",
     "@babel/preset-env": "^7.13.10",
-    "@babel/preset-typescript": "^7.16.7",
     "@babel/register": "^7.13.8",
     "babel-loader": "^8.2.2",
     "copyfiles": "^2.4.1",
@@ -60,9 +57,8 @@
     "csv-streamify": "4.0.0",
     "eslint": "^8.0.1",
     "eslint-plugin-compat": "^3.13.0",
-    "eslint-plugin-import": "^2.25.4",
     "fetch-mock": "^9.11.0",
-    "karma": "^6.3.16",
+    "karma": "^6.3.2",
     "karma-chrome-launcher": "^3.1.0",
     "karma-tap": "4.1.4",
     "karma-webpack": "^5.0.0",
@@ -84,10 +80,10 @@
   },
   "scripts": {
     "build-es": "rimraf es && cross-env NODE_ENV=es babel ./src -d es --ignore 'src/**/__tests__/*'",
-    "postbuild-es": "cross-env NODE_ENV=es node scripts/copy.packages.json.js && ./scripts/build_esm_replace_imports.sh",
+    "postbuild-es": "cross-env NODE_ENV=es node scripts/copy.packages.json.js",
     "build-umd:stats": "webpack --progress --env production --json > ./stats/stat_results.json",
     "build-cjs": "rimraf lib && cross-env NODE_ENV=cjs babel ./src -d lib --ignore 'src/**/__tests__/*'",
-    "postbuild-cjs": "cross-env NODE_ENV=cjs node scripts/copy.packages.json.js && ./scripts/build_cjs_replace_imports.sh",
+    "postbuild-cjs": "cross-env NODE_ENV=cjs node scripts/copy.packages.json.js",
     "build-umd": "webpack --config webpack.ci.dev.js --env branch=$BUILD_BRANCH --env commit_hash=$BUILD_COMMIT && webpack --config webpack.ci.prod.js --env branch=$BUILD_BRANCH --env commit_hash=$BUILD_COMMIT && ./scripts/clean_umd_build.sh",
     "build-umd:local": "webpack --config webpack.dev.js && webpack --config webpack.prod.js && ./scripts/clean_umd_build.sh",
     "build:local": "rimraf lib umd es && npm run build-cjs && npm run build-es && npm run build-umd:local",
@@ -95,7 +91,7 @@
     "build": "rimraf lib umd es && npm run build-cjs && npm run build-es && npm run build-umd",
     "check": "npm run check:lint && npm run check:version",
     "check:lint": "eslint src",
-    "check:version": "cross-env NODE_ENV=test tape -r ./babel.register src/settings/__tests__/defaults.spec.js",
+    "check:version": "cross-env NODE_ENV=test tape -r @babel/register src/utils/__tests__/settings/index.spec.js",
     "test-browser-local": "cross-env NODE_ENV=test karma start karma/local.karma.conf.js",
     "test-browser-e2e-local": "cross-env NODE_ENV=test karma start karma/e2e.local.karma.conf.js",
     "test-browser": "npm run test-browser-unit && npm run test-browser-online && npm run test-browser-offline && npm run test-browser-destroy && npm run test-browser-errors && npm run test-browser-push && npm run test-browser-gaintegration",
@@ -107,13 +103,13 @@
     "test-browser-gaintegration": "cross-env NODE_ENV=test karma start karma/gaintegration.ci.karma.conf.js",
     "test-browser-push": "cross-env NODE_ENV=test karma start karma/push.ci.karma.conf.js",
     "test-node": "npm run test-node-unit && npm run test-node-online && npm run test-node-redis && npm run test-node-offline && npm run test-node-destroy && npm run test-node-errors && npm run test-node-push",
-    "test-node-unit": "cross-env NODE_ENV=test tape -r ./babel.register \"src/*/**/__tests__/**/!(browser).spec.js\" | tap-min",
-    "test-node-online": "cross-env NODE_ENV=test tape -r ./babel.register src/__tests__/node.spec.js | tap-min",
-    "test-node-destroy": "cross-env NODE_ENV=test tape -r ./babel.register src/__tests__/destroy/node.spec.js | tap-min",
-    "test-node-errors": "cross-env NODE_ENV=test tape -r ./babel.register src/__tests__/errorCatching/node.spec.js | tap-min",
-    "test-node-offline": "cross-env NODE_ENV=test tape -r ./babel.register src/__tests__/offline/node.spec.js | tap-min",
-    "test-node-redis": "cross-env NODE_ENV=test tape -r ./babel.register \"src/__tests__/node_redis.spec.js\" | tap-min",
-    "test-node-push": "cross-env NODE_ENV=test tape -r ./babel.register src/__tests__/push/node.spec.js | tap-min",
+    "test-node-unit": "cross-env NODE_ENV=test tape -r @babel/register \"src/*/**/__tests__/**/!(browser).spec.js\" | tap-min",
+    "test-node-online": "cross-env NODE_ENV=test tape -r @babel/register src/__tests__/node.spec.js | tap-min",
+    "test-node-destroy": "cross-env NODE_ENV=test tape -r @babel/register src/__tests__/destroy/node.spec.js | tap-min",
+    "test-node-errors": "cross-env NODE_ENV=test tape -r @babel/register src/__tests__/errorCatching/node.spec.js | tap-min",
+    "test-node-offline": "cross-env NODE_ENV=test tape -r @babel/register src/__tests__/offline/node.spec.js | tap-min",
+    "test-node-redis": "cross-env NODE_ENV=test tape -r @babel/register \"src/__tests__/node_redis.spec.js\" | tap-min",
+    "test-node-push": "cross-env NODE_ENV=test tape -r @babel/register src/__tests__/push/node.spec.js | tap-min",
     "pretest-ts-decls": "npm run build-es && npm run build-cjs && npm link",
     "test-ts-decls": "./scripts/ts-tests.sh",
     "posttest-ts-decls": "npm unlink && npm install",

package/src/client/attributesDecoration.js

@@ -0,0 +1,112 @@
+import ClientInputValidationLayer from './inputValidation';
+import AttributesCacheInMemory from '../storage/AttributesCache/InMemory';
+import { validateAttributesDeep } from '../utils/inputValidation/attributes';
+import logFactory from '../utils/logger';
+import objectAssign from 'object-assign';
+const log = logFactory('splitio-client');
+
+/**
+ * Add in memory attributes storage methods and combine them with any attribute received from the getTreatment/s call 
+ */
+export default function ClientAttributesDecorationLayer(context, isKeyBinded, isTTBinded) {
+
+  const client = ClientInputValidationLayer(context, isKeyBinded, isTTBinded);
+
+  const attributeStorage = new AttributesCacheInMemory();
+
+  // Keep a reference to the original methods
+  const clientGetTreatment = client.getTreatment;
+  const clientGetTreatmentWithConfig = client.getTreatmentWithConfig;
+  const clientGetTreatments = client.getTreatments;
+  const clientGetTreatmentsWithConfig = client.getTreatmentsWithConfig;
+
+  /**
+   * Add an attribute to client's in memory attributes storage
+   * 
+   * @param {string} attributeName Attrinute name
+   * @param {string, number, boolean, list} attributeValue Attribute value
+   * @returns {boolean} true if the attribute was stored and false otherways
+   */
+  client.setAttribute = (attributeName, attributeValue) => {
+    const attribute = {};
+    attribute[attributeName] = attributeValue;
+    if (!validateAttributesDeep(attribute)) return false;
+    log.debug(`stored ${attributeValue} for attribute ${attributeName}`);
+    return attributeStorage.setAttribute(attributeName, attributeValue);
+  };
+
+  /**
+   * Returns the attribute with the given key
+   * 
+   * @param {string} attributeName Attribute name
+   * @returns {Object} Attribute with the given key
+   */
+  client.getAttribute = (attributeName) => {
+    log.debug(`retrieved attribute ${attributeName}`);
+    return attributeStorage.getAttribute(attributeName + '');
+  };
+
+  /**
+   * Add to client's in memory attributes storage the attributes in 'attributes'
+   * 
+   * @param {Object} attributes Object with attributes to store
+   * @returns true if attributes were stored an false otherways
+   */
+  client.setAttributes = (attributes) => {
+    if (!validateAttributesDeep(attributes)) return false;
+    return attributeStorage.setAttributes(attributes);
+  };
+
+  /**
+   * Return all the attributes stored in client's in memory attributes storage
+   * 
+   * @returns {Object} returns all the stored attributes
+   */
+  client.getAttributes = () => {
+    return attributeStorage.getAll();
+  };
+
+  /**
+   * Removes from client's in memory attributes storage the attribute with the given key
+   * 
+   * @param {string} attributeName 
+   * @returns {boolean} true if attribute was removed and false otherways
+   */
+  client.removeAttribute = (attributeName) => {
+    log.debug(`removed attribute ${attributeName}`);
+    return attributeStorage.removeAttribute(attributeName + '');
+  };
+
+  /**
+   * Remove all the stored attributes in the client's in memory attribute storage
+   */
+  client.clearAttributes = () => {
+    return attributeStorage.clear();
+  };
+
+  client.getTreatment = (maybeKey, maybeSplit, maybeAttributes) => {
+    return clientGetTreatment(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
+  };
+
+  client.getTreatmentWithConfig = (maybeKey, maybeSplit, maybeAttributes) => {
+    return clientGetTreatmentWithConfig(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
+  };
+
+  client.getTreatments = (maybeKey, maybeSplits, maybeAttributes) => {
+    return clientGetTreatments(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
+  };
+
+  client.getTreatmentsWithConfig = (maybeKey, maybeSplits, maybeAttributes) => {
+    return clientGetTreatmentsWithConfig(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
+  };
+
+  function combineAttributes(maybeAttributes) {
+    const storedAttributes = attributeStorage.getAll();
+    if (Object.keys(storedAttributes).length > 0) {
+      return objectAssign({}, storedAttributes, maybeAttributes);
+    }
+    return maybeAttributes;
+  }
+
+  return client;
+}

package/src/client/browser.js

@@ -0,0 +1,41 @@
+import { get } from '../utils/lang';
+import ClientAttributesDecorationLayer from './attributesDecoration';
+import { LOCALHOST_MODE } from '../utils/constants';
+import {
+  validateKey,
+  validateTrafficType,
+} from '../utils/inputValidation';
+
+function BrowserClientFactory(context) {
+  const settings = context.get(context.constants.SETTINGS);
+  const maybeKey = get(settings, 'core.key', undefined);
+  const maybeTT = get(settings, 'core.trafficType', undefined);
+
+  if (settings.mode === LOCALHOST_MODE && maybeKey === undefined) {
+    settings.core.key = 'localhost_key';
+  } else {
+    settings.core.key = validateKey(maybeKey, 'Client instantiation');
+  }
+
+  // Key is also binded to the .track method. Same thing happens with trafficType but only if present on configs. (not required)
+  const trackBindings = [settings.core.key];
+  if (maybeTT !== undefined) {
+    const tt = validateTrafficType(maybeTT, 'Client instantiation');
+    settings.core.trafficType = tt;
+    trackBindings.push(tt);
+  }
+
+  const client = ClientAttributesDecorationLayer(context, true, trackBindings.length > 1);
+  client.isBrowserClient = true;
+
+  // In the browser land, we can bind the key and the traffic type (if provided)
+  client.getTreatment = client.getTreatment.bind(client, settings.core.key);
+  client.getTreatmentWithConfig = client.getTreatmentWithConfig.bind(client, settings.core.key);
+  client.getTreatments = client.getTreatments.bind(client, settings.core.key);
+  client.getTreatmentsWithConfig = client.getTreatmentsWithConfig.bind(client, settings.core.key);
+  client.track = client.track.bind(client, ...trackBindings);
+
+  return client;
+}
+
+export default BrowserClientFactory;

package/src/client/client.js

@@ -0,0 +1,131 @@
+import logFactory from '../utils/logger';
+const log = logFactory('splitio-client');
+import { evaluateFeature, evaluateFeatures } from '../engine/evaluator';
+import ImpressionsTracker from '../trackers/impressions';
+import EventTracker from '../trackers/event';
+import tracker from '../utils/timeTracker';
+import thenable from '../utils/promise/thenable';
+import { matching, bucketing } from '../utils/key/factory';
+/* asynchronous validations that live on the client. */
+import { validateSplitExistance, validateTrafficTypeExistance } from '../utils/inputValidation';
+import { SDK_NOT_READY } from '../utils/labels';
+import { CONTROL } from '../utils/constants';
+
+function ClientFactory(context) {
+  const storage = context.get(context.constants.STORAGE);
+  const metricCollectors = context.get(context.constants.COLLECTORS);
+  const impressionsTracker = ImpressionsTracker(context);
+  const eventTracker = EventTracker(context);
+
+  function getTreatment(key, splitName, attributes, withConfig = false) {
+    const taskToBeTracked = tracker.TaskNames[withConfig ? 'SDK_GET_TREATMENT_WITH_CONFIG' : 'SDK_GET_TREATMENT'];
+    const stopLatencyTracker = tracker.start(taskToBeTracked, metricCollectors);
+    const evaluation = evaluateFeature(key, splitName, attributes, storage);
+
+    const wrapUp = (evaluationResult) => {
+      const treatment = processEvaluation(evaluationResult, splitName, key, attributes, withConfig, `getTreatment${withConfig ? 'withConfig' : ''}`);
+      impressionsTracker.track();
+      stopLatencyTracker();
+      return treatment;
+    };
+
+    return thenable(evaluation) ? evaluation.then((res) => wrapUp(res)) : wrapUp(evaluation);
+  }
+
+  function getTreatmentWithConfig(key, splitName, attributes) {
+    return getTreatment(key, splitName, attributes, true);
+  }
+
+  function getTreatments(key, splitNames, attributes, withConfig = false) {
+    const taskToBeTracked = tracker.TaskNames[withConfig ? 'SDK_GET_TREATMENTS_WITH_CONFIG' : 'SDK_GET_TREATMENTS'];
+    const stopLatencyTracker = tracker.start(taskToBeTracked, metricCollectors);
+
+    const wrapUp = (evaluationResults) => {
+      const results = {};
+      Object.keys(evaluationResults).forEach(splitName => {
+        results[splitName] = processEvaluation(evaluationResults[splitName], splitName, key, attributes, withConfig, `getTreatments${withConfig ? 'withConfig' : ''}`);
+      });
+      impressionsTracker.track();
+      stopLatencyTracker();
+      return results;
+    };
+
+    const evaluations = evaluateFeatures(key, splitNames, attributes, storage);
+
+    return thenable(evaluations) ? evaluations.then((res) => wrapUp(res)) : wrapUp(evaluations);
+  }
+
+  function getTreatmentsWithConfig(key, splitNames, attributes) {
+    return getTreatments(key, splitNames, attributes, true);
+  }
+
+  // Internal function
+  function processEvaluation(
+    evaluation,
+    splitName,
+    key,
+    attributes,
+    withConfig,
+    invokingMethodName
+  ) {
+    const isSdkReady = context.get(context.constants.READY, true) || context.get(context.constants.READY_FROM_CACHE, true);
+    const matchingKey = matching(key);
+    const bucketingKey = bucketing(key);
+
+    // If the SDK was not ready, treatment may be incorrect due to having Splits but not segments data.
+    if (!isSdkReady) {
+      evaluation = { treatment: CONTROL, label: SDK_NOT_READY };
+    }
+
+    const { treatment, label, changeNumber, config = null } = evaluation;
+    log.info(`Split: ${splitName}. Key: ${matchingKey}. Evaluation: ${treatment}. Label: ${label}`);
+
+    if (validateSplitExistance(context, splitName, label, invokingMethodName)) {
+      log.info('Queueing corresponding impression.');
+      impressionsTracker.queue({
+        feature: splitName,
+        keyName: matchingKey,
+        treatment,
+        time: Date.now(),
+        bucketingKey,
+        label,
+        changeNumber
+      }, attributes);
+    }
+
+    if (withConfig) {
+      return {
+        treatment,
+        config
+      };
+    }
+
+    return treatment;
+  }
+
+  function track(key, trafficTypeName, eventTypeId, value = null, properties = null, size = 1024) {
+    const matchingKey = matching(key);
+    const timestamp = Date.now();
+    const eventData = {
+      eventTypeId,
+      trafficTypeName,
+      value,
+      timestamp,
+      key: matchingKey,
+      properties
+    };
+
+    // This may be async but we only warn, we don't actually care if it is valid or not in terms of queueing the event.
+    validateTrafficTypeExistance(trafficTypeName, context, 'track');
+
+    return eventTracker.track(eventData, size);
+  }
+
+  return {
+    getTreatment, getTreatmentWithConfig,
+    getTreatments, getTreatmentsWithConfig,
+    track
+  };
+}
+
+export default ClientFactory;