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

package/src/utils/now/browser.js

@@ -0,0 +1,29 @@
+/**
+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 nowFactory() {
+  // eslint-disable-next-line compat/compat
+  if (typeof performance === 'object' && typeof performance.now === 'function') {
+    // eslint-disable-next-line compat/compat
+    return performance.now.bind(performance);
+  } else {
+    return Date.now;
+  }
+}
+
+const now = nowFactory();
+
+export default now;

package/src/utils/now/node.js

@@ -0,0 +1,21 @@
+/**
+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.
+**/
+
+export default function now() {
+  let time = process.hrtime();
+
+  return time[0] * 1e3 + time[1] * 1e-6; // convert it to milis
+}

package/src/utils/now/package.json

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

package/src/utils/promise/thenable.js

@@ -0,0 +1 @@
+export default o => o !== undefined && o !== null && typeof o.then === 'function';

package/src/utils/promise/timeout.js

@@ -0,0 +1,38 @@
+/**
+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 { SplitTimeoutError } from '../lang/Errors';
+
+function timeout(ms, promise) {
+  if (ms < 1) return promise;
+
+  return new Promise((resolve, reject) => {
+    const tid = setTimeout(() => {
+      reject(new SplitTimeoutError(`Operation timed out because it exceeded the configured time limit of ${ms}ms.`));
+    }, ms);
+
+    promise.then((res) => {
+      clearTimeout(tid);
+      resolve(res);
+    },
+    (err) => {
+      clearTimeout(tid);
+      reject(err);
+    });
+  });
+}
+
+export default timeout;

package/src/utils/promise/wrapper.js

@@ -0,0 +1,60 @@
+/**
+ * wraps a given promise in a new one with a default onRejected function,
+ * that handles the promise rejection if not other onRejected handler is provided.
+ *
+ * Caveats:
+ *  - There are some cases where the `defaultOnRejected` handler is not invoked
+ * and the promise rejection must be handled by the user (same as the Promise spec):
+ *    - using async/await syntax with a transpiler to Promises
+ *    - setting an `onFinally` handler as the first handler (e.g. `promiseWrapper(Promise.reject()).finally(...)`)
+ *    - setting more than one handler with at least one of them being an onRejected handler
+ *  - If the wrapped promise is rejected when using native async/await syntax, the `defaultOnRejected` handler is invoked
+ * and neither the catch block nor the remaining try block are executed.
+ *
+ * @param customPromise promise to wrap
+ * @param defaultOnRejected default onRejected function
+ * @returns a promise that doesn't need to be handled for rejection (except when using async/await syntax) and
+ * with a method named `hasOnFulfilled` that returns true if the promise has attached an onFulfilled handler.
+ */
+export default function promiseWrapper(customPromise, defaultOnRejected) {
+
+  let hasOnFulfilled = false;
+  let hasOnRejected = false;
+
+  function chain(promise) {
+    const newPromise = new Promise((res, rej) => {
+      return promise.then(
+        res,
+        function (value) {
+          if (hasOnRejected) {
+            rej(value);
+          } else {
+            defaultOnRejected(value);
+          }
+        }
+      );
+    });
+
+    const originalThen = newPromise.then;
+
+    // Using `defineProperty` in case Promise.prototype.then property is not writable
+    Object.defineProperty(newPromise, 'then', {
+      value: function (onfulfilled, onrejected) {
+        const result = originalThen.call(newPromise, onfulfilled, onrejected);
+        if (typeof onfulfilled === 'function') hasOnFulfilled = true;
+        if (typeof onrejected === 'function') {
+          hasOnRejected = true;
+          return result;
+        } else {
+          return chain(result);
+        }
+      }
+    });
+
+    return newPromise;
+  }
+
+  const result = chain(customPromise);
+  result.hasOnFulfilled = () => hasOnFulfilled;
+  return result;
+}

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

@@ -0,0 +1,12 @@
+export default {
+  startup: {
+    // Stress the request time used while starting up the SDK.
+    requestTimeoutBeforeReady: 5,
+    // How many quick retries we will do while starting up the SDK.
+    retriesOnFailureBeforeReady: 1,
+    // Maximum amount of time used before notifies me a timeout.
+    readyTimeout: 10, 
+    // Amount of time we will wait before the first push of events.
+    eventsFirstPushWindow: 10
+  }
+};

package/src/utils/settings/defaults/node.js

@@ -0,0 +1,21 @@
+export default {
+  core: {
+    // Default is true.
+    IPAddressesEnabled: true
+  },
+  startup: {
+    // Stress the request time used while starting up the SDK.
+    requestTimeoutBeforeReady: 15,
+    // How many quick retries we will do while starting up the SDK.
+    retriesOnFailureBeforeReady: 1,
+    // Maximum amount of time used before notifies me a timeout.
+    readyTimeout: 15,
+    // Don't wait a specific time for first flush on Node, no page load here.
+    eventsFirstPushWindow: 0
+  },
+  scheduler: {
+    featuresRefreshRate: 5,
+    impressionsRefreshRate: 300
+  },
+  features: '.split'
+};

package/src/utils/settings/defaults/package.json

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

package/src/utils/settings/impressionsMode.js

@@ -0,0 +1,15 @@
+import { DEBUG, OPTIMIZED } from '../constants';
+import logFactory from '../logger';
+const log = logFactory('splitio-settings');
+
+function validImpressionsMode(impressionsMode) {
+  impressionsMode = impressionsMode.toUpperCase();
+  if ([DEBUG, OPTIMIZED].indexOf(impressionsMode) === -1) {
+    log.error(`You passed an invalid impressionsMode, impressionsMode should be one of the following values: '${DEBUG}' or '${OPTIMIZED}'. Defaulting to '${OPTIMIZED}' mode.`);
+    impressionsMode = OPTIMIZED;
+  }
+
+  return impressionsMode;
+}
+
+export default validImpressionsMode;

package/src/utils/settings/index.js

@@ -0,0 +1,217 @@
+/**
+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 { merge } from '../lang';
+import language from './language';
+import runtime from './runtime';
+import overridesPerPlatform from './defaults';
+import storage from './storage';
+import integrations from './integrations';
+import mode from './mode';
+import validateSplitFilters from '../inputValidation/splitFilters';
+import { API } from '../../utils/logger';
+import { STANDALONE_MODE, STORAGE_MEMORY, CONSUMER_MODE, OPTIMIZED } from '../../utils/constants';
+import validImpressionsMode from './impressionsMode';
+
+const version = '10.17.3-rc.4';
+const eventsEndpointMatcher = /^\/(testImpressions|metrics|events)/;
+const authEndpointMatcher = /^\/v2\/auth/;
+const streamingEndpointMatcher = /^\/(sse|event-stream)/;
+
+const base = {
+  // Define which kind of object you want to retrieve from SplitFactory
+  mode: STANDALONE_MODE,
+
+  core: {
+    // API token (tight to an environment)
+    authorizationKey: undefined,
+    // key used in your system (only required for browser version)
+    key: undefined,
+    // traffic type for the given key (only used on browser version)
+    trafficType: undefined,
+    // toggle impressions tracking of labels
+    labelsEnabled: true,
+    // toggle sendind (true) or not sending (false) IP and Host Name with impressions, events, and telemetries requests (only used on nodejs version)
+    IPAddressesEnabled: undefined
+  },
+
+  scheduler: {
+    // fetch feature updates each 30 sec
+    featuresRefreshRate: 30,
+    // fetch segments updates each 60 sec
+    segmentsRefreshRate: 60,
+    // publish metrics each 120 sec
+    metricsRefreshRate: 120,
+    // publish evaluations each 60 sec
+    impressionsRefreshRate: 60,
+    // fetch offline changes each 15 sec
+    offlineRefreshRate: 15,
+    // publish events every 60 seconds after the first flush
+    eventsPushRate: 60,
+    // how many events will be queued before flushing
+    eventsQueueSize: 500,
+    // backoff base seconds to wait before re attempting to connect to push notifications
+    pushRetryBackoffBase: 1,
+  },
+
+  urls: {
+    // CDN having all the information for your environment
+    sdk: 'https://sdk.split.io/api',
+    // Storage for your SDK events
+    events: 'https://events.split.io/api',
+    // SDK Auth Server
+    auth: 'https://auth.split.io/api',
+    // Streaming Server
+    streaming: 'https://streaming.split.io',
+  },
+
+  // Defines which kind of storage we should instanciate.
+  storage: {
+    type: STORAGE_MEMORY
+  },
+
+  // Defines if the logs are enabled, SDK wide.
+  debug: undefined,
+
+  // Defines the impression listener, but will only be used on NodeJS.
+  impressionListener: undefined,
+
+  // Instance version.
+  version: `${language}-${version}`,
+
+  // List of integrations.
+  integrations: undefined,
+
+  // toggle using (true) or not using (false) Server-Side Events for synchronizing storage
+  streamingEnabled: true,
+
+  sync: {
+    splitFilters: undefined,
+    // impressions collection mode
+    impressionsMode: OPTIMIZED
+  }
+};
+
+function fromSecondsToMillis(n) {
+  return Math.round(n * 1000);
+}
+
+function setupLogger(debugValue) {
+  if (typeof debugValue === 'boolean') {
+    if (debugValue) {
+      API.enable();
+    } else {
+      API.disable();
+    }
+  } else if (typeof debugValue === 'string') {
+    API.setLogLevel(debugValue);
+  }
+}
+
+function defaults(custom) {
+  const withDefaults = merge({}, base, overridesPerPlatform, custom);
+
+  // Scheduler periods
+  withDefaults.scheduler.featuresRefreshRate = fromSecondsToMillis(withDefaults.scheduler.featuresRefreshRate);
+  withDefaults.scheduler.segmentsRefreshRate = fromSecondsToMillis(withDefaults.scheduler.segmentsRefreshRate);
+  withDefaults.scheduler.metricsRefreshRate = fromSecondsToMillis(withDefaults.scheduler.metricsRefreshRate);
+  withDefaults.scheduler.impressionsRefreshRate = fromSecondsToMillis(withDefaults.scheduler.impressionsRefreshRate);
+  withDefaults.scheduler.offlineRefreshRate = fromSecondsToMillis(withDefaults.scheduler.offlineRefreshRate);
+  withDefaults.scheduler.eventsPushRate = fromSecondsToMillis(withDefaults.scheduler.eventsPushRate);
+
+  // Startup periods
+  withDefaults.startup.requestTimeoutBeforeReady = fromSecondsToMillis(withDefaults.startup.requestTimeoutBeforeReady);
+  withDefaults.startup.readyTimeout = fromSecondsToMillis(withDefaults.startup.readyTimeout);
+  withDefaults.startup.eventsFirstPushWindow = fromSecondsToMillis(withDefaults.startup.eventsFirstPushWindow);
+
+  // ensure a valid SDK mode
+  withDefaults.mode = mode(withDefaults.core.authorizationKey, withDefaults.mode);
+
+  // ensure a valid Storage based on mode defined.
+  withDefaults.storage = storage(withDefaults);
+
+  setupLogger(withDefaults.debug);
+
+  // Current ip/hostname information
+  withDefaults.runtime = runtime(withDefaults.core.IPAddressesEnabled, withDefaults.mode === CONSUMER_MODE);
+
+  // ensure a valid list of integrations.
+  // `integrations` returns an array of valid integration items.
+  withDefaults.integrations = integrations(withDefaults);
+
+  // validate push options
+  if (withDefaults.streamingEnabled !== false) {
+    withDefaults.streamingEnabled = true;
+    // Backoff bases.
+    // We are not checking if bases are positive numbers. Thus, we might be reauthenticating immediately (`setTimeout` with NaN or negative number)
+    withDefaults.scheduler.pushRetryBackoffBase = fromSecondsToMillis(withDefaults.scheduler.pushRetryBackoffBase);
+  }
+
+  // validate the `splitFilters` settings and parse splits query
+  const splitFiltersValidation = validateSplitFilters(withDefaults.sync.splitFilters, withDefaults.mode);
+  withDefaults.sync.splitFilters = splitFiltersValidation.validFilters;
+  withDefaults.sync.__splitFiltersValidation = splitFiltersValidation;
+
+  // ensure a valid impressionsMode
+  withDefaults.sync.impressionsMode = validImpressionsMode(withDefaults.sync.impressionsMode);
+
+  return withDefaults;
+}
+
+const proto = {
+  /**
+   * Switch URLs servers based on target.
+   *
+   * @param {String} target url target
+   * @return {String} completed url
+   */
+  url(target) {
+    if (eventsEndpointMatcher.test(target)) {
+      return `${this.urls.events}${target}`;
+    }
+    if (authEndpointMatcher.test(target)) {
+      return `${this.urls.auth}${target}`;
+    }
+    if (streamingEndpointMatcher.test(target)) {
+      return `${this.urls.streaming}${target}`;
+    }
+    return `${this.urls.sdk}${target}`;
+  },
+
+  /**
+   * Returns a settings clone with the key and traffic type (if provided) overriden.
+   * @param {SplitKey} key
+   * @param {string} [trafficType]
+   */
+  overrideKeyAndTT(key, trafficType) {
+    return objectAssign(
+      Object.create(proto),
+      this, {
+        core: objectAssign({},
+          this.core, {
+            key,
+            trafficType
+          }
+        )
+      }
+    );
+  }
+};
+
+const SettingsFactory = (settings) => objectAssign(Object.create(proto), defaults(settings));
+
+export default SettingsFactory;

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

@@ -0,0 +1,8 @@
+import { GOOGLE_ANALYTICS_TO_SPLIT, SPLIT_TO_GOOGLE_ANALYTICS } from '../../../utils/constants';
+import validateIntegrationsSettings from './common';
+
+const validateBrowserIntegrationsSettings = settings => {
+  return validateIntegrationsSettings(settings, [GOOGLE_ANALYTICS_TO_SPLIT, SPLIT_TO_GOOGLE_ANALYTICS]);
+};
+
+export default validateBrowserIntegrationsSettings;

package/src/utils/settings/integrations/common.js

@@ -0,0 +1,32 @@
+import logFactory from '../../../utils/logger';
+import { isString } from '../../../utils/lang';
+const log = logFactory('splitio-settings');
+
+/**
+ * This function validates `settings.integrations` object
+ *
+ * @param {Object} settings SDK settings object to validate
+ * @param {Array<string>} validIntegrationTypes list of integration types to filter from `settings.integrations`
+ *
+ * @returns {Array} array of valid integration items. The array might be empty if `settings` object does not have valid integrations.
+ */
+const validateIntegrationsSettings = (settings, validIntegrationTypes = []) => {
+  const { integrations } = settings;
+
+  // If integrations is not an array or an empty array, we return an empty array (no integrations).
+  if (!Array.isArray(integrations) || integrations.length === 0)
+    return [];
+
+  // We remove invalid integration items
+  const validIntegrations = integrations.filter(integration => {
+    return integration && isString(integration.type) && validIntegrationTypes.indexOf(integration.type) > -1;
+  });
+
+  const invalids = integrations.length - validIntegrations.length;
+  if (invalids)
+    log.warn(`${invalids} integration ${invalids === 1 ? 'item' : 'items'} at settings ${invalids === 1 ? 'is' : 'are'} invalid: integration items must have a valid 'type' value`);
+
+  return validIntegrations;
+};
+
+export default validateIntegrationsSettings;

package/src/utils/settings/integrations/node.js

@@ -0,0 +1,7 @@
+// For now, Node SDK does not support integrations,
+// thus any integrations settings is parsed into undefined.
+const validateNodeIntegrationsSettings = () => {
+  return [];
+};
+
+export default validateNodeIntegrationsSettings;

package/src/utils/settings/integrations/package.json

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

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

@@ -0,0 +1,17 @@
+/**
+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.
+**/
+
+export default 'javascript';

package/src/utils/settings/language/node.js

@@ -0,0 +1,17 @@
+/**
+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.
+**/
+
+export default 'nodejs';

package/src/utils/settings/language/package.json

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

package/src/utils/settings/mode.js

@@ -0,0 +1,12 @@
+import { LOCALHOST_MODE, STANDALONE_MODE, PRODUCER_MODE, CONSUMER_MODE } from '../constants';
+
+function mode(key, mode) {
+  // Leaving the comparison as is, in case we change the mode name but not the setting.
+  if (key === 'localhost') return LOCALHOST_MODE;
+
+  if ([STANDALONE_MODE, PRODUCER_MODE, CONSUMER_MODE].indexOf(mode) === -1) throw Error('Invalid mode provided');
+
+  return mode;
+}
+
+export default mode;

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

@@ -0,0 +1,22 @@
+/**
+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.
+**/
+
+export default function generateRuntimeSettings() {
+  return {
+    ip: false,
+    hostname: false
+  };
+}

package/src/utils/settings/runtime/node.js

@@ -0,0 +1,34 @@
+/**
+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 osFunction from 'os';
+import ipFunction from 'ip';
+
+import { UNKNOWN, NA } from '../../constants';
+
+export default function generateRuntimeSettings(isIPAddressesEnabled, isConsumerMode) {
+  // If the values are not available, default to false (for standalone) or "unknown" (for consumer mode, to be used on Redis keys)
+  let ip = ipFunction.address() || (isConsumerMode ? UNKNOWN : false);
+  let hostname = osFunction.hostname() || (isConsumerMode ? UNKNOWN : false);
+  
+  if (!isIPAddressesEnabled) { // If IPAddresses setting is not enabled, set as false (for standalone) or "NA" (for consumer mode, to  be used on Redis keys)
+    ip = hostname = isConsumerMode ? NA : false;
+  }
+  
+  return {
+    ip, hostname
+  };
+}

package/src/utils/settings/runtime/package.json

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