@splitsoftware/splitio 10.17.2 → 10.17.3-rc.3

package/src/storage/AttributesCache/InMemory.js

@@ -1,76 +0,0 @@
-import objectAssign from 'object-assign';
-
-class AttributesCacheInMemory {
-
-  constructor() {
-    this.attributesCache = {};
-  }
-
-  /**
-   * Create or update the value for the given attribute
-   *
-   * @param {string} attributeName attribute name
-   * @param {Object} attributeValue attribute value
-   * @returns {boolean} the attribute was stored
-   */
-  setAttribute(attributeName, attributeValue) {
-    this.attributesCache[attributeName] = attributeValue;
-    return true;
-  }
-
-  /**
-   * Retrieves the value of a given attribute
-   *
-   * @param {string} attributeName attribute name
-   * @returns {Object?} stored attribute value
-   */
-  getAttribute(attributeName) {
-    return this.attributesCache[attributeName];
-  }
-
-  /**
-   * Create or update all the given attributes
-   *
-   * @param {[string, Object]} attributes attributes to create or update
-   * @returns {boolean} attributes were stored
-   */
-  setAttributes(attributes) {
-    this.attributesCache = objectAssign(this.attributesCache, attributes);
-    return true;
-  }
-
-  /**
-   * Retrieve the full attributes map
-   *
-   * @returns {Map<string, Object>} stored attributes
-   */
-  getAll() {
-    return this.attributesCache;
-  }
-
-  /**
-   * Removes a given attribute from the map
-   *
-   * @param {string} attributeName attribute to remove
-   * @returns {boolean} attribute removed
-   */
-  removeAttribute(attributeName) {
-    if (Object.keys(this.attributesCache).indexOf(attributeName) >= 0) {
-      delete this.attributesCache[attributeName];
-      return true;
-    }
-    return false;
-  }
-
-  /**
-   * Clears all attributes stored in the SDK
-   *
-   */
-  clear() {
-    this.attributesCache = {};
-    return true;
-  }
-
-}
-
-export default AttributesCacheInMemory;

package/src/storage/BaseMetricsAsyncCache.js

@@ -1,14 +0,0 @@
-export default class BaseMetricsAsyncCache {
-  /**
-   * Async storage caches will always count as empty from an SDK Producer point of view.
-   */
-  isEmpty() {
-    return true;
-  }
-  /**
-   * On async storages we will save metrics on Redis but nothing more. No clean ups or consumptions.
-   */
-  clear() {
-    // noop.
-  }
-}

package/src/storage/CountCache/InMemory.js

@@ -1,48 +0,0 @@
-/**
-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.
-**/
-
-class CountCacheInMemory {
-  constructor() {
-    this.clear();
-  }
-
-  clear() {
-    this.counters = {};
-
-    return this;
-  }
-
-  state() {
-    return this.counters;
-  }
-
-  track(metricName) {
-    if (this.counters[metricName] === undefined) this.counters[metricName] = 1;
-    else this.counters[metricName]++;
-
-    return this.counters[metricName];
-  }
-
-  isEmpty() {
-    return Object.keys(this.counters).length === 0;
-  }
-
-  toJSON() {
-    return this.counters;
-  }
-}
-
-export default CountCacheInMemory;

package/src/storage/CountCache/InRedis.js

@@ -1,32 +0,0 @@
-/**
-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 BaseMetricsAsyncCache from '../BaseMetricsAsyncCache';
-
-class CountCacheInRedis extends BaseMetricsAsyncCache {
-  constructor(keys, redis) {
-    super();
-    this.keys = keys;
-    this.redis = redis;
-  }
-
-  track(metricName) {
-    return this.redis.incr(this.keys.buildCountKey(metricName)).catch(() => {
-      // noop, for telemetry metrics there's no need to throw.
-    });
-  }
-}
-
-export default CountCacheInRedis;

package/src/storage/EventsCache/InMemory.js

@@ -1,99 +0,0 @@
-/**
-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 thenable from '../../utils/promise/thenable';
-
-const MAX_QUEUE_BYTE_SIZE = 5 * 1024 * 1024; // 5M
-
-class EventsCache {
-
-  constructor(context) {
-    const settings = context.get(context.constants.SETTINGS);
-    const eventsModule = context.get(context.constants.EVENTS);
-
-    this.onFullQueue = false;
-    this.maxQueue = settings.scheduler.eventsQueueSize;
-    this.queue = [];
-    this.queueByteSize = 0;
-
-    if (thenable(eventsModule)) {
-      eventsModule.then(events => {
-        this.onFullQueue = events.flushAndResetTimer;
-        this._checkForFlush(); // Events is ready, check the queue.
-      });
-    } else if (typeof eventsModule.flushAndResetTimer === 'function') {
-      this.onFullQueue = eventsModule.flushAndResetTimer;
-    }
-  }
-
-  /**
-   * Get the current state of the queue.
-   */
-  state() {
-    return this.queue;
-  }
-
-  /**
-   * Add a new event object at the end of the queue.
-   */
-  track(data, size = 0) {
-    this.queueByteSize += size;
-    this.queue.push(data);
-
-    this._checkForFlush();
-
-    return true;
-  }
-
-  /**
-   * Clear the data stored on the cache.
-   */
-  clear() {
-    this.queue = [];
-    this.queueByteSize = 0;
-
-    return this;
-  }
-
-  /**
-   * Returns the payload we will use for posting data.
-   */
-  toJSON() {
-    return this.queue;
-  }
-
-  /**
-   * Check if the cache is empty.
-   */
-  isEmpty() {
-    return this.queue.length === 0;
-  }
-
-  /**
-   * Check if the cache queue is full and we need to flush it.
-   */
-  _checkForFlush() {
-    if (
-      (this.queueByteSize > MAX_QUEUE_BYTE_SIZE) ||
-      // 0 means no maximum value, in case we want to avoid this being triggered. Size limit is not affected by it.
-      (this.maxQueue > 0 && this.queue.length >= this.maxQueue)
-    ) {
-      this.onFullQueue && this.onFullQueue();
-    }
-  }
-}
-
-export default EventsCache;

package/src/storage/EventsCache/InRedis.js

@@ -1,62 +0,0 @@
-/**
-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-storage:redis');
-
-class EventsCache {
-  constructor(keys, redis, meta) {
-    this.keys = keys;
-    this.redis = redis;
-    this.meta = meta;
-
-    this.eventsKey = keys.buildEventsKey();
-  }
-
-  /**
-   * Add a new event object into the queue.
-   */
-  track(eventData) {
-    return this.redis.rpush(
-      this.eventsKey,
-      this._toJSON(eventData)
-    )
-      // We use boolean values to signal successful queueing
-      .then(() => true)
-      .catch(err => {
-        log.error(`Error adding event to queue: ${err}.`);
-        return false;
-      });
-  }
-
-  /**
-   * Generates the JSON as we'll store it on Redis.
-   */
-  _toJSON(eventData) {
-    return JSON.stringify({
-      m: this.meta,
-      e: eventData
-    });
-  }
-
-  /**
-   * We are returning true because the go syncronizer push the impressions from redis.
-   */
-  isEmpty() {
-    return true;
-  }
-}
-
-export default EventsCache;

package/src/storage/ImpressionsCache/InMemory.js

@@ -1,62 +0,0 @@
-/**
-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.
-**/
-
-class ImpressionsCacheInMemory {
-  constructor() {
-    this.queue = [];
-  }
-
-  /**
-   * Get collected data
-   */
-  state() {
-    return this.queue;
-  }
-
-  /**
-   * Store objects in sequential order
-   */
-  track(data) {
-    this.queue.push(...data);
-
-    return this;
-  }
-
-  /**
-   * Recycle the collector queue
-   */
-  clear() {
-    this.queue.length = 0;
-
-    return this;
-  }
-
-  /**
-   * Hook JSON.stringify to expose the state of the counters
-   */
-  toJSON() {
-    return this.queue;
-  }
-
-  /**
-   * Check if the is data changed from the defaults
-   */
-  isEmpty() {
-    return this.queue.length === 0;
-  }
-}
-
-export default ImpressionsCacheInMemory;

package/src/storage/ImpressionsCache/InRedis.js

@@ -1,65 +0,0 @@
-/**
-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.
-**/
-
-class ImpressionsCacheInRedis {
-  constructor(keys, redis, meta) {
-    this.keys = keys;
-    this.redis = redis;
-    this.meta = meta;
-  }
-
-  track(impressions) {
-    return this.redis.rpush(
-      this.keys.buildImpressionsKey(),
-      this.toJSON(impressions)
-    ).then(queuedCount => {
-      // If this is the creation of the key on Redis, set the expiration for it in 1hr.
-      if (queuedCount === impressions.length) {
-        return this.redis.expire(this.keys.buildImpressionsKey(), 3600);
-      }
-    });
-  }
-
-  toJSON(impressions) {
-    return impressions.map(impression => {
-      const {
-        keyName, bucketingKey, feature, treatment, label, time, changeNumber
-      } = impression;
-
-      return JSON.stringify({
-        m: this.meta,
-        i: {
-          k: keyName,
-          b: bucketingKey,
-          f: feature,
-          t: treatment,
-          r: label,
-          c: changeNumber,
-          m: time
-        }
-      });
-    });
-  }
-
-  /**
-   * We are returning true because the go syncronizer push the impressions from redis.
-   */
-  isEmpty() {
-    return true;
-  }
-}
-
-export default ImpressionsCacheInRedis;

package/src/storage/Keys.js

@@ -1,122 +0,0 @@
-import { startsWith } from '../utils/lang';
-
-const everythingAtTheEnd = /[^.]+$/;
-const everythingAfterCount = /count\.([^/]+)$/;
-const latencyMetricNameAndBucket = /latency\.([^/]+)\.bucket\.([0-9]+)$/;
-
-class KeyBuilder {
-  constructor(settings) {
-    this.settings = settings;
-  }
-
-  buildSplitKey(splitName) {
-    return `${this.settings.storage.prefix}.split.${splitName}`;
-  }
-
-  buildTrafficTypeKey(trafficType) {
-    return `${this.settings.storage.prefix}.trafficType.${trafficType}`;
-  }
-
-  buildSplitsTillKey() {
-    return `${this.settings.storage.prefix}.splits.till`;
-  }
-
-  buildSplitsReady() {
-    return `${this.settings.storage.prefix}.splits.ready`;
-  }
-
-  isSplitKey(key) {
-    return startsWith(key, `${this.settings.storage.prefix}.split.`);
-  }
-
-  buildSegmentNameKey(segmentName) {
-    return `${this.settings.storage.prefix}.segment.${segmentName}`;
-  }
-
-  buildSegmentTillKey(segmentName) {
-    return `${this.settings.storage.prefix}.segment.${segmentName}.till`;
-  }
-
-  buildRegisteredSegmentsKey() {
-    return `${this.settings.storage.prefix}.segments.registered`;
-  }
-
-  buildSegmentsReady() {
-    return `${this.settings.storage.prefix}.segments.ready`;
-  }
-
-  buildVersionablePrefix() {
-    return `${this.settings.storage.prefix}/${this.settings.version}/${this.settings.runtime.ip}`;
-  }
-
-  buildImpressionsKey() {
-    return `${this.settings.storage.prefix}.impressions`;
-  }
-
-  buildEventsKey() {
-    return `${this.settings.storage.prefix}.events`;
-  }
-
-  buildLatencyKeyPrefix() {
-    return `${this.buildVersionablePrefix()}/latency`;
-  }
-
-  buildLatencyKey(metricName, bucketNumber) {
-    return `${this.buildLatencyKeyPrefix()}.${metricName}.bucket.${bucketNumber}`;
-  }
-
-  buildCountKey(metricName) {
-    return `${this.buildVersionablePrefix()}/count.${metricName}`;
-  }
-
-  buildGaugeKey(metricName) {
-    return `${this.buildVersionablePrefix()}/gauge.${metricName}`;
-  }
-
-  searchPatternForCountKeys() {
-    return `${this.buildVersionablePrefix()}/count.*`;
-  }
-
-  searchPatternForSplitKeys() {
-    return `${this.settings.storage.prefix}.split.*`;
-  }
-
-  searchPatternForLatency() {
-    return `${this.buildLatencyKeyPrefix()}.*`;
-  }
-
-  extractKey(builtKey) {
-    const s = builtKey.match(everythingAtTheEnd);
-
-    if (s && s.length) {
-      return s[0];
-    } else {
-      throw new Error('Invalid latency key provided');
-    }
-  }
-
-  extractCounterName(counterKey) {
-    const m = counterKey.match(everythingAfterCount);
-
-    if (m && m.length) {
-      return m[1]; // everything after count
-    } else {
-      throw new Error('Invalid counter key provided');
-    }
-  }
-
-  extractLatencyMetricNameAndBucket(latencyKey) {
-    const parts = latencyKey.match(latencyMetricNameAndBucket);
-
-    if (parts && parts.length > 2) {
-      return {
-        metricName: parts[1],
-        bucketNumber: parts[2]
-      };
-    } else {
-      throw new Error('Invalid counter key provided');
-    }
-  }
-}
-
-export default KeyBuilder;

package/src/storage/KeysLocalStorage.js

@@ -1,40 +0,0 @@
-import { startsWith } from '../utils/lang';
-import KeyBuilder from './Keys';
-import { matching } from '../utils/key/factory';
-
-class KeyBuilderForLocalStorage extends KeyBuilder {
-
-  constructor(settings) {
-    super(settings);
-    this.regexSplitCacheKey = new RegExp(`^${this.settings.storage.prefix}\\.(splits?|trafficType)\\.`);
-  }
-
-  buildSegmentNameKey(segmentName) {
-    return `${matching(this.settings.core.key)}.${this.settings.storage.prefix}.segment.${segmentName}`;
-  }
-
-  extractSegmentName(builtSegmentKeyName) {
-    const prefix = `${matching(this.settings.core.key)}.${this.settings.storage.prefix}.segment.`;
-
-    if (startsWith(builtSegmentKeyName, prefix))
-      return builtSegmentKeyName.substr(prefix.length);
-  }
-
-  buildSplitsWithSegmentCountKey() {
-    return `${this.settings.storage.prefix}.splits.usingSegments`;
-  }
-
-  buildLastUpdatedKey() {
-    return `${this.settings.storage.prefix}.splits.lastUpdated`;
-  }
-
-  isSplitCacheKey(key) {
-    return this.regexSplitCacheKey.test(key);
-  }
-
-  buildSplitsFilterQueryKey() {
-    return `${this.settings.storage.prefix}.splits.filterQuery`;
-  }
-}
-
-export default KeyBuilderForLocalStorage;

package/src/storage/LatencyCache/InMemory.js

@@ -1,56 +0,0 @@
-/**
-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 findIndex from './findIndex';
-
-class LatencyCacheInMemory {
-  constructor() {
-    this.clear();
-  }
-
-  clear() {
-    this.counters = {};
-
-    return this;
-  }
-
-  state() {
-    return this.counters;
-  }
-
-  track(metricName, latency) {
-    // Initialize if needed
-    if (this.counters[metricName] === undefined) {
-      this.counters[metricName] = [
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-      ];
-    }
-
-    // +1 based on the latency number
-    this.counters[metricName][findIndex(latency)]++;
-
-    return this;
-  }
-
-  isEmpty() {
-    return Object.keys(this.counters).length === 0;
-  }
-
-  toJSON() {
-    return this.counters;
-  }
-}
-
-export default LatencyCacheInMemory;