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

package/src/trackers/impressions.js

@@ -0,0 +1,123 @@
+/**
+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 objectAssign from 'object-assign';
+import logFactory from '../utils/logger';
+import thenable from '../utils/promise/thenable';
+import ImpressionObserverFactory from '../impressions/observer';
+import { truncateTimeFrame } from '../utils/time';
+import { OPTIMIZED, PRODUCER_MODE, STANDALONE_MODE } from '../utils/constants';
+const log = logFactory('splitio-client:impressions-tracker');
+
+/**
+ * Checks if impressions previous time should be added or not.
+ */
+function shouldAddPt(settings) {
+  return [PRODUCER_MODE, STANDALONE_MODE].indexOf(settings.mode) > -1 ? true : false;
+}
+
+/**
+ * Checks if it should dedupe impressions or not.
+ */
+function shouldBeOptimized(settings) {
+  if (!shouldAddPt(settings)) return false;
+  return settings.sync.impressionsMode === OPTIMIZED ? true : false;
+}
+
+function ImpressionsTracker(context) {
+  const collector = context.get(context.constants.STORAGE).impressions;
+  const settings = context.get(context.constants.SETTINGS);
+  const listener = settings.impressionListener;
+  const integrationsManager = context.get(context.constants.INTEGRATIONS_MANAGER, true);
+  const { ip, hostname } = settings.runtime;
+  const sdkLanguageVersion = settings.version;
+  const queue = [];
+  const shouldAddPreviousTime = shouldAddPt(settings);
+  const isOptimized = shouldBeOptimized(settings);
+  const observer = ImpressionObserverFactory(); // Instantiates observer
+  const impressionsCounter = context.get(context.constants.IMPRESSIONS_COUNTER);
+
+  return {
+    queue: function (impression, attributes) {
+      queue.push({
+        impression,
+        attributes
+      });
+    },
+    track: function () {
+      const impressionsCount = queue.length;
+      const slice = queue.splice(0, impressionsCount);
+
+      const impressionsToStore = []; // Track only the impressions that are going to be stored
+      // Wraps impressions to store and adds previousTime if it corresponds
+      slice.forEach(({ impression }) => {
+        if (shouldAddPreviousTime) {
+          // Adds previous time if it is enabled
+          impression.pt = observer.testAndSet(impression);
+        }
+
+        const now = Date.now();
+        if (isOptimized && impressionsCounter) {
+          // Increments impression counter per featureName
+          impressionsCounter.inc(impression.feature, now, 1);
+        }
+
+        // Checks if the impression should be added in queue to be sent
+        if (!isOptimized || !impression.pt || impression.pt < truncateTimeFrame(now)) {
+          impressionsToStore.push(impression);
+        }
+      });
+
+      const res = collector.track(impressionsToStore);
+
+      // If we're on an async storage, handle error and log it.
+      if (thenable(res)) {
+        res.then(() => {
+          log.debug(`Successfully stored ${impressionsCount} impression${impressionsCount === 1 ? '' : 's'}.`);
+        }).catch(err => {
+          log.error(`Could not store impressions bulk with ${impressionsCount} impression${impressionsCount === 1 ? '' : 's'}. Error: ${err}`);
+        });
+      }
+
+      if (listener || integrationsManager) {
+        for (let i = 0; i < impressionsCount; i++) {
+          const impressionData = {
+            // copy of impression, to avoid unexpected behaviour if modified by integrations or impressionListener
+            impression: objectAssign({}, slice[i].impression),
+            attributes: slice[i].attributes,
+            ip,
+            hostname,
+            sdkLanguageVersion
+          };
+
+          // Wrap in a timeout because we don't want it to be blocking.
+          setTimeout(function () {
+            // integrationsManager.handleImpression does not throw errors
+            if (integrationsManager) integrationsManager.handleImpression(impressionData);
+
+            try { // An exception on the listeners should not break the SDK.
+              if (listener) listener.logImpression(impressionData);
+            } catch (err) {
+              log.error(`Impression listener logImpression method threw: ${err}.`);
+            }
+          }, 0);
+        }
+      }
+    }
+  };
+}
+
+export default ImpressionsTracker;

package/src/umd.js

@@ -1,4 +1,3 @@
 import { SplitFactory } from './index';
 
-// eslint-disable-next-line import/no-default-export
 export default SplitFactory;

package/src/utils/backoff/index.js

@@ -0,0 +1,46 @@
+class Backoff {
+
+  /**
+   * Schedule function calls with exponential backoff
+   *
+   * @param {function} cb
+   * @param {number} baseMillis
+   * @param {number} maxMillis
+   */
+  constructor(cb, baseMillis, maxMillis) {
+    this.baseMillis = baseMillis || Backoff.DEFAULT_BASE_MILLIS;
+    this.maxMillis = maxMillis || Backoff.DEFAULT_MAX_MILLIS;
+    this.attempts = 0;
+    this.cb = cb;
+  }
+
+  /**
+   * Schedule a next call to `cb`
+   * @returns scheduled delay in milliseconds
+   */
+  scheduleCall() {
+    let delayInMillis = Math.min(this.baseMillis * Math.pow(2, this.attempts), this.maxMillis);
+
+    if (this.timeoutID) clearTimeout(this.timeoutID);
+    this.timeoutID = setTimeout(() => {
+      this.cb();
+    }, delayInMillis);
+    this.attempts++;
+
+    return delayInMillis;
+  }
+
+  reset() {
+    this.attempts = 0;
+    if (this.timeoutID) {
+      clearTimeout(this.timeoutID);
+      this.timeoutID = 0;
+    }
+  }
+
+}
+
+Backoff.DEFAULT_BASE_MILLIS = 1000; // 1 second
+Backoff.DEFAULT_MAX_MILLIS = 1800000; // 30 minutes
+
+export default Backoff;

package/src/utils/base64/browser.js

@@ -0,0 +1,19 @@
+/**
+ * Decode a given string value in Base64 format
+ *
+ * @param {string} value to decode
+ * @throws {ReferenceError} if `atob` function is not defined
+ */
+export function decodeFromBase64(value) {
+  return atob(value);
+}
+
+/**
+ * Encode a given string value to Base64 format.
+ *
+ * @param {string} value to encode
+ * @throws {ReferenceError} if `btoa` function is not defined
+ */
+export function encodeToBase64(value) {
+  return btoa(value);
+}

package/src/utils/base64/node.js

@@ -0,0 +1,19 @@
+/**
+ * Decode a given string value in Base64 format
+ *
+ * @param {string} value to decode
+ */
+export function decodeFromBase64(value) {
+  // for node (version mayor than v4)
+  return Buffer.from(value, 'base64').toString('binary');
+}
+
+/**
+ * Encode a given string value to Base64 format
+ *
+ * @param {string} value to encode
+ */
+export function encodeToBase64(value) {
+  // for node (version mayor than v4)
+  return Buffer.from(value).toString('base64');
+}

package/src/utils/base64/package.json

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

package/src/utils/binarySearch/index.js

@@ -0,0 +1,50 @@
+/**
+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 bs(items, value) {
+  let startIndex = 0;
+  let stopIndex = items.length - 1;
+  let middle = Math.floor((stopIndex + startIndex) / 2);
+  let minIndex = startIndex;
+  let maxIndex = stopIndex;
+
+  while (items[middle] !== value && startIndex < stopIndex) {
+    // adjust search area
+    if (value < items[middle]) {
+      stopIndex = middle - 1;
+    } else if (value > items[middle]) {
+      startIndex = middle + 1;
+    }
+
+    // recalculate middle
+    middle = Math.floor((stopIndex + startIndex) / 2);
+  }
+
+  // correct if middle is out of range
+  if (middle < minIndex) {
+    middle = minIndex;
+  } else if (middle > maxIndex) {
+    middle = maxIndex;
+  }
+
+  // we want to always return based on strict minor comparation
+  if (value < items[middle] && middle > minIndex) {
+    return middle - 1;
+  }
+
+  return middle;
+}
+
+export default bs;

package/src/utils/constants/index.js

@@ -0,0 +1,41 @@
+// SDK Modes
+export const LOCALHOST_MODE = 'localhost';
+export const STANDALONE_MODE = 'standalone';
+export const PRODUCER_MODE = 'producer';
+export const CONSUMER_MODE = 'consumer';
+// Storage types
+export const STORAGE_MEMORY = 'MEMORY';
+export const STORAGE_REDIS = 'REDIS';
+export const STORAGE_LOCALSTORAGE = 'LOCALSTORAGE';
+// Special treatments
+export const CONTROL = 'control';
+export const CONTROL_WITH_CONFIG = {
+  treatment: CONTROL,
+  config: null
+};
+// Constants for unknown and not-applicable values
+export const UNKNOWN = 'unknown';
+export const NA = 'NA';
+// Integration types
+export const GOOGLE_ANALYTICS_TO_SPLIT = 'GOOGLE_ANALYTICS_TO_SPLIT';
+export const SPLIT_TO_GOOGLE_ANALYTICS = 'SPLIT_TO_GOOGLE_ANALYTICS';
+// Integration data types
+export const SPLIT_IMPRESSION = 'IMPRESSION';
+export const SPLIT_EVENT = 'EVENT';
+// Split filters metadata.
+// Ordered according to their precedency when forming the filter query string: `&names=<values>&prefixes=<values>`
+export const FILTERS_METADATA = [
+  {
+    type: 'byName',
+    maxLength: 400,
+    queryParam: 'names='
+  },
+  {
+    type: 'byPrefix',
+    maxLength: 50,
+    queryParam: 'prefixes='
+  }
+];
+// Impression collection modes
+export const DEBUG = 'DEBUG';
+export const OPTIMIZED = 'OPTIMIZED';

package/src/utils/context/constants.js

@@ -0,0 +1,18 @@
+export const COLLECTORS = 'metrics_collectors';
+export const DESTROYED = 'is_destroyed';
+export const EVENTS = 'events_publisher';
+export const HAS_TIMEDOUT = 'has_timedout';
+export const INTEGRATIONS_MANAGER = 'integrations_manager';
+export const MY_SEGMENTS_CHANGE_WORKER = 'my_segments_change_worker';
+export const PRODUCER = 'producer';
+export const READINESS = 'readiness_gate';
+export const READY = 'is_ready';
+export const READY_FROM_CACHE = 'is_ready_from_cache';
+export const SETTINGS = 'settings';
+export const STATUS_MANAGER = 'status_manager';
+export const STORAGE = 'storage';
+export const IMPRESSIONS_COUNTER = 'impressions_counter';
+
+export default {
+  COLLECTORS, DESTROYED, EVENTS, HAS_TIMEDOUT, INTEGRATIONS_MANAGER, MY_SEGMENTS_CHANGE_WORKER, PRODUCER, READINESS, READY, READY_FROM_CACHE, SETTINGS, STATUS_MANAGER, STORAGE, IMPRESSIONS_COUNTER
+};

package/src/utils/context/index.js

@@ -0,0 +1,84 @@
+/**
+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 objectAssign from 'object-assign';
+import thenable from '../promise/thenable';
+import constants from './constants';
+
+class Context {
+  constructor() {
+    this._map = {};
+    this.constants = constants;
+  }
+  /**
+   * Gets an item in the context instance or a promise if the item is not yet stored and we are not doing a one time check.
+   * @param {String} name - The name of the item we want to get
+   * @return {Any} The item we want to get.
+   */
+  get(name, flagCheck = false) {
+    if (typeof name !== 'string' || typeof name === 'string' && !name.length) return; // Wrong usage, don't generate item promise.
+
+    const item = this._map[name];
+
+    // If we have the item, return it.
+    if (item !== undefined) {
+      return item;
+    } else if (!flagCheck) { // If we don't and it's not a flag check, return a promise that we will resolve once we receive the item.
+      let resolve;
+      const promise = new Promise(res => resolve = res);
+      promise.manualResolve = resolve;
+      this._map[name] = promise;
+      return promise;
+    }
+  }
+  /**
+   * Gets all objects stored in the context.
+   * @return {Object} - A new map of context-stored items.
+   */
+  getAll() { return objectAssign({}, this._map); }
+  /**
+   * Stores an item in the context instance.
+   * @param {String} name - The name of what we are storing
+   * @param {Any} item - The item can be of any type.
+   * @return {Boolean} - The result of the operation
+   */
+  put(name, item) {
+    if (typeof name !== 'string' || (typeof name === 'string' && !name.length) || item === undefined) return false; // We can't store this.
+
+    const existingItem = this._map[name];
+
+    // Item already exists and no one is waiting for the item. Abort and return false.
+    if (existingItem !== undefined && typeof existingItem.manualResolve !== 'function') return false;
+
+    // Someone is waiting for this item, resolve to it.
+    if (thenable(existingItem) && existingItem.manualResolve) existingItem.manualResolve(item);
+
+    // We are storing a promise, when resolving save the item. On error, clean up the item.
+    if (thenable(item)) {
+      item.then(item => {
+        this._map[name] = item;
+        return item;
+      }).catch(err => {
+        this._map[name] = undefined;
+        return err;
+      });
+    }
+
+    this._map[name] = item;
+    return true;
+  }
+}
+
+export default Context;