@splitsoftware/splitio 10.17.3-rc.2 → 10.17.3

package/es/engine/transforms/matchers.js

@@ -0,0 +1,109 @@
+/**
+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 '../../utils/lang';
+import { matcherTypes, matcherTypesMapper, matcherDataTypes } from '../matchers/types';
+import segmentTransform from './segment';
+import whitelistTransform from './whitelist';
+import setTransform from './set';
+import numericTransform from './unaryNumeric';
+import { zeroSinceHH, zeroSinceSS } from '../convertions'; // Flat the complex matcherGroup structure into something handy.
+
+function transform(matchers) {
+  var parsedMatchers = matchers.map(function (matcher) {
+    var matcherType = matcher.matcherType,
+        negate = matcher.negate,
+        keySelector = matcher.keySelector,
+        segmentObject = matcher.userDefinedSegmentMatcherData,
+        whitelistObject = matcher.whitelistMatcherData,
+        unaryNumericObject = matcher.unaryNumericMatcherData,
+        betweenObject = matcher.betweenMatcherData,
+        dependencyObject = matcher.dependencyMatcherData,
+        booleanMatcherData = matcher.booleanMatcherData,
+        stringMatcherData = matcher.stringMatcherData;
+    var attribute = keySelector && keySelector.attribute;
+    var type = matcherTypesMapper(matcherType); // As default input data type we use string (even for ALL_KEYS)
+
+    var dataType = matcherDataTypes.STRING;
+    var value = undefined;
+
+    if (type === matcherTypes.IN_SEGMENT) {
+      value = segmentTransform(segmentObject);
+    } else if (type === matcherTypes.WHITELIST) {
+      value = whitelistTransform(whitelistObject);
+    } else if (type === matcherTypes.EQUAL_TO) {
+      value = numericTransform(unaryNumericObject);
+      dataType = matcherDataTypes.NUMBER;
+
+      if (unaryNumericObject.dataType === 'DATETIME') {
+        value = zeroSinceHH(value);
+        dataType = matcherDataTypes.DATETIME;
+      }
+    } else if (type === matcherTypes.GREATER_THAN_OR_EQUAL_TO || type === matcherTypes.LESS_THAN_OR_EQUAL_TO) {
+      value = numericTransform(unaryNumericObject);
+      dataType = matcherDataTypes.NUMBER;
+
+      if (unaryNumericObject.dataType === 'DATETIME') {
+        value = zeroSinceSS(value);
+        dataType = matcherDataTypes.DATETIME;
+      }
+    } else if (type === matcherTypes.BETWEEN) {
+      value = betweenObject;
+      dataType = matcherDataTypes.NUMBER;
+
+      if (betweenObject.dataType === 'DATETIME') {
+        value.start = zeroSinceSS(value.start);
+        value.end = zeroSinceSS(value.end);
+        dataType = matcherDataTypes.DATETIME;
+      }
+    } else if (type === matcherTypes.EQUAL_TO_SET || type === matcherTypes.CONTAINS_ANY_OF_SET || type === matcherTypes.CONTAINS_ALL_OF_SET || type === matcherTypes.PART_OF_SET) {
+      value = setTransform(whitelistObject);
+      dataType = matcherDataTypes.SET;
+    } else if (type === matcherTypes.STARTS_WITH || type === matcherTypes.ENDS_WITH || type === matcherTypes.CONTAINS_STRING) {
+      value = setTransform(whitelistObject);
+    } else if (type === matcherTypes.IN_SPLIT_TREATMENT) {
+      value = dependencyObject;
+      dataType = matcherDataTypes.NOT_SPECIFIED;
+    } else if (type === matcherTypes.EQUAL_TO_BOOLEAN) {
+      dataType = matcherDataTypes.BOOLEAN;
+      value = booleanMatcherData;
+    } else if (type === matcherTypes.MATCHES_STRING) {
+      value = stringMatcherData;
+    }
+
+    return {
+      attribute: attribute,
+      // attribute over we should do the matching, undefined means 'use the key'
+      negate: negate,
+      // should we negate the result?
+      type: type,
+      // which kind of matcher we should evaluate
+      value: value,
+      // metadata used for the matching
+      dataType: dataType // runtime input data type
+
+    };
+  });
+
+  if (findIndex(parsedMatchers, function (m) {
+    return m.type === matcherTypes.UNDEFINED;
+  }) === -1) {
+    return parsedMatchers;
+  } else {
+    return [];
+  }
+}
+
+export default transform;

package/es/engine/transforms/segment.js

@@ -0,0 +1,28 @@
+/**
+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.
+**/
+
+/**
+ * Extract segment name as a plain string.
+ */
+function transform(segment) {
+  if (segment === void 0) {
+    segment = {};
+  }
+
+  return segment.segmentName;
+}
+
+export default transform;

package/es/engine/transforms/set.js

@@ -0,0 +1,20 @@
+/**
+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 transform(whitelistObject) {
+  return whitelistObject.whitelist;
+}
+
+export default transform;

package/es/engine/transforms/unaryNumeric.js

@@ -0,0 +1,20 @@
+/**
+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 transform(unaryNumericObject) {
+  return unaryNumericObject.value;
+}
+
+export default transform;

package/es/engine/transforms/whitelist.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.
+**/
+import { _Set } from '../../utils/lang/Sets';
+
+function transform(whitelistObject) {
+  return new _Set(whitelistObject.whitelist);
+}
+
+export default transform;

package/es/engine/treatments/index.js

@@ -0,0 +1,67 @@
+/**
+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 '../../utils/lang';
+
+function Treatments(ranges, treatments) {
+  if (!(this instanceof Treatments)) {
+    return new Treatments(ranges, treatments);
+  }
+
+  if (ranges[ranges.length - 1] !== 100) {
+    throw new RangeError('Provided invalid dataset as input');
+  }
+
+  this._ranges = ranges;
+  this._treatments = treatments;
+}
+
+Treatments.parse = function parse(data) {
+  var _data$reduce = data.reduce(function (accum, value) {
+    var size = value.size,
+        treatment = value.treatment;
+    accum.ranges.push(accum.inc += size);
+    accum.treatments.push(treatment);
+    return accum;
+  }, {
+    inc: 0,
+    ranges: [],
+    treatments: []
+  }),
+      ranges = _data$reduce.ranges,
+      treatments = _data$reduce.treatments;
+
+  return new Treatments(ranges, treatments);
+};
+
+Treatments.prototype.getTreatmentFor = function getTreatmentFor(x) {
+  if (x < 0 || x > 100) {
+    throw new RangeError('Please provide a value between 0 and 100');
+  } // Readme [1]
+  // We need to manually add any dependency which escape of dummy resolution
+  // I'll deal with this in a future release
+  // for (let [k, r] of this._ranges.entries()) {
+  //   if (x <= r) return this._treatments[k];
+  // }
+
+
+  var index = findIndex(this._ranges, function (range) {
+    return x <= range;
+  });
+  var treatment = this._treatments[index];
+  return treatment;
+};
+
+export default Treatments;

package/es/engine/value/index.js

@@ -0,0 +1,54 @@
+/**
+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';
+var log = logFactory('splitio-engine:value');
+import sanitizeValue from './sanitize';
+
+function parseValue(key, attributeName, attributes) {
+  var value = undefined;
+
+  if (attributeName) {
+    if (attributes) {
+      value = attributes[attributeName];
+      log.debug("Extracted attribute [" + attributeName + "], [" + value + "] will be used for matching.");
+    } else {
+      log.warn("Defined attribute [" + attributeName + "], no attributes received.");
+    }
+  } else {
+    value = key;
+  }
+
+  return value;
+}
+/**
+ * Defines value to be matched (key / attribute).
+ */
+
+
+function value(key, matcherDto, attributes) {
+  var attributeName = matcherDto.attribute;
+  var valueToMatch = parseValue(key, attributeName, attributes);
+  var sanitizedValue = sanitizeValue(matcherDto.type, valueToMatch, matcherDto.dataType, attributes);
+
+  if (sanitizedValue !== undefined) {
+    return sanitizedValue;
+  } else {
+    log.warn("Value " + valueToMatch + " " + (attributeName ? "for attribute " + attributeName + " " : +'') + "doesn't match with expected type.");
+    return;
+  }
+}
+
+export default value;

package/es/engine/value/sanitize.js

@@ -0,0 +1,125 @@
+/**
+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';
+var log = logFactory('splitio-engine:sanitize');
+import { isObject, uniq, toString, toNumber } from '../../utils/lang';
+import { zeroSinceHH, zeroSinceSS } from '../convertions';
+import { matcherTypes, matcherDataTypes } from '../matchers/types';
+
+function sanitizeNumber(val) {
+  var num = toNumber(val);
+  return isNaN(num) ? undefined : num;
+}
+
+function sanitizeString(val) {
+  var valueToSanitize = val;
+
+  if (isObject(val)) {
+    // If the value is an object and is not a key, discard it.
+    valueToSanitize = val.matchingKey ? val.matchingKey : undefined;
+  }
+
+  var str = toString(valueToSanitize);
+  return str ? str : undefined;
+}
+
+function sanitizeArray(val) {
+  var arr = Array.isArray(val) ? uniq(val.map(function (e) {
+    return e + '';
+  })) : [];
+  return arr.length ? arr : undefined;
+}
+
+function sanitizeBoolean(val) {
+  if (val === true || val === false) return val;
+
+  if (typeof val === 'string') {
+    var lowerCaseValue = val.toLocaleLowerCase();
+    if (lowerCaseValue === 'true') return true;
+    if (lowerCaseValue === 'false') return false;
+  }
+
+  return undefined;
+}
+
+function dependencyProcessor(sanitizedValue, attributes) {
+  return {
+    key: sanitizedValue,
+    attributes: attributes
+  };
+}
+/**
+ * We can define a pre-processing for the value, to be executed prior to matcher evaluation.
+ */
+
+
+function getProcessingFunction(matcherTypeID, dataType) {
+  switch (matcherTypeID) {
+    case matcherTypes.EQUAL_TO:
+      return dataType === 'DATETIME' ? zeroSinceHH : undefined;
+
+    case matcherTypes.GREATER_THAN_OR_EQUAL_TO:
+    case matcherTypes.LESS_THAN_OR_EQUAL_TO:
+    case matcherTypes.BETWEEN:
+      return dataType === 'DATETIME' ? zeroSinceSS : undefined;
+
+    case matcherTypes.IN_SPLIT_TREATMENT:
+      return dependencyProcessor;
+
+    default:
+      return undefined;
+  }
+}
+
+function sanitizeValue(matcherTypeID, value, dataType, attributes) {
+  var processor = getProcessingFunction(matcherTypeID, dataType);
+  var sanitizedValue;
+
+  switch (dataType) {
+    case matcherDataTypes.NUMBER:
+    case matcherDataTypes.DATETIME:
+      sanitizedValue = sanitizeNumber(value);
+      break;
+
+    case matcherDataTypes.STRING:
+      sanitizedValue = sanitizeString(value);
+      break;
+
+    case matcherDataTypes.SET:
+      sanitizedValue = sanitizeArray(value);
+      break;
+
+    case matcherDataTypes.BOOLEAN:
+      sanitizedValue = sanitizeBoolean(value);
+      break;
+
+    case matcherDataTypes.NOT_SPECIFIED:
+      sanitizedValue = value;
+      break;
+
+    default:
+      sanitizedValue = undefined;
+  }
+
+  if (processor) {
+    sanitizedValue = processor(sanitizedValue, attributes);
+  }
+
+  log.debug("Attempted to sanitize [" + value + "] which should be of type [" + dataType + "]. \n Sanitized and processed value => [" + (sanitizedValue instanceof Object ? JSON.stringify(sanitizedValue) : sanitizedValue) + "]");
+  return sanitizedValue;
+}
+
+export default sanitizeValue;

package/es/events/index.js

@@ -0,0 +1,65 @@
+import logFactory from '../utils/logger';
+var log = logFactory('splitio-events');
+import tracker from '../utils/timeTracker';
+import repeat from '../utils/fn/repeat';
+import eventsService from '../services/events';
+import eventsBulkRequest from '../services/events/bulk';
+
+var EventsFactory = function EventsFactory(context) {
+  var settings = context.get(context.constants.SETTINGS);
+  var storage = context.get(context.constants.STORAGE);
+
+  var pushEvents = function pushEvents() {
+    if (storage.events.isEmpty()) return Promise.resolve();
+    log.info("Pushing " + storage.events.state().length + " queued events.");
+    var latencyTrackerStop = tracker.start(tracker.TaskNames.EVENTS_PUSH);
+    var json = JSON.stringify(storage.events.toJSON());
+
+    var wrapUpCb = function wrapUpCb() {
+      return latencyTrackerStop();
+    };
+
+    storage.events.clear(); // we always clear the queue.
+
+    return eventsService(eventsBulkRequest(settings, {
+      body: json
+    })).then(wrapUpCb).catch(wrapUpCb);
+  };
+
+  var stopEventPublisherTimeout = false;
+  var stopEventsPublisher = false;
+
+  var startEventsPublisher = function startEventsPublisher() {
+    return stopEventsPublisher = repeat(function (schedulePublisher) {
+      return pushEvents().then(function () {
+        return schedulePublisher();
+      });
+    }, settings.scheduler.eventsPushRate);
+  };
+
+  return {
+    start: function start() {
+      // On the browser there may be a wish to wait an specific amount of seconds before the first push.
+      if (settings.startup.eventsFirstPushWindow > 0) {
+        stopEventPublisherTimeout = setTimeout(startEventsPublisher, settings.startup.eventsFirstPushWindow);
+      } else {
+        startEventsPublisher();
+      }
+    },
+    flush: function flush() {
+      return pushEvents();
+    },
+    stop: function stop() {
+      stopEventPublisherTimeout && clearTimeout(stopEventPublisherTimeout);
+      stopEventsPublisher && stopEventsPublisher();
+    },
+    flushAndResetTimer: function flushAndResetTimer() {
+      // Reset the timer and push the events.
+      log.info('Flushing events and reseting timer.');
+      stopEventsPublisher && stopEventsPublisher.reset();
+      return pushEvents();
+    }
+  };
+};
+
+export default EventsFactory;

package/es/factory/offline.js

@@ -0,0 +1,50 @@
+import objectAssign from 'object-assign';
+import ClientFactory from '../client';
+import OfflineProducerFactory from '../producer/offline';
+import { releaseApiKey } from '../utils/inputValidation'; //
+// Create SDK instance for offline mode.
+//
+
+function SplitFactoryOffline(context, sharedTrackers) {
+  var sharedInstance = !sharedTrackers;
+  var readiness = context.get(context.constants.READINESS);
+  var storage = context.get(context.constants.STORAGE);
+  var statusManager = context.get(context.constants.STATUS_MANAGER); // In LOCALHOST mode, shared clients are ready in the next event-loop cycle than created
+  // and then updated on each SDK_SPLITS_ARRIVED event
+
+  if (sharedInstance) setTimeout(function () {
+    readiness.splits.on(readiness.splits.SDK_SPLITS_ARRIVED, function () {
+      readiness.gate.emit(readiness.gate.SDK_UPDATE);
+    });
+    readiness.gate.emit(readiness.gate.SDK_READY);
+  }, 0); // Producer
+
+  var producer = sharedInstance ? undefined : OfflineProducerFactory(context); // Start background task for flag updates
+
+  producer && producer.start();
+  var api = objectAssign( // Proto linkage of the EventEmitter to prevent any change
+  Object.create(statusManager), // GetTreatment/s
+  ClientFactory(context), // Utilities
+  {
+    // Destroy instance. Async so we respect the online api.
+    destroy: function destroy() {
+      // Stop background jobs
+      producer && producer.stop(); // Cleanup event listeners
+
+      readiness.destroy(); // Cleanup storage
+
+      storage.destroy && storage.destroy(); // Mark the factory as destroyed.
+
+      context.put(context.constants.DESTROYED, true);
+      !sharedInstance && releaseApiKey();
+      return Promise.resolve();
+    }
+  });
+  return {
+    api: api,
+    metricCollectors: false // We won't collect any metrics on localhost mode.
+
+  };
+}
+
+export default SplitFactoryOffline;

package/es/factory/online.js

@@ -0,0 +1,113 @@
+import objectAssign from 'object-assign';
+import ClientFactory from '../client';
+import MetricsFactory from '../metrics';
+import EventsFactory from '../events';
+import SyncManagerFactory from '../sync';
+import SignalsListener from '../listeners';
+import { releaseApiKey } from '../utils/inputValidation';
+import { STANDALONE_MODE, PRODUCER_MODE, CONSUMER_MODE } from '../utils/constants'; // map of authorizationKeys to syncManagers, to keep a single instance per factory and needed to create shared clients
+
+var syncManagers = {}; //
+// Create SDK instance based on the provided configurations
+//
+
+function SplitFactoryOnline(context, readyTrackers, mainClientMetricCollectors) {
+  var sharedInstance = !!mainClientMetricCollectors;
+  var settings = context.get(context.constants.SETTINGS);
+  var readiness = context.get(context.constants.READINESS);
+  var storage = context.get(context.constants.STORAGE);
+  var statusManager = context.get(context.constants.STATUS_MANAGER); // We are only interested in exposable EventEmitter
+
+  var gate = readiness.gate,
+      splits = readiness.splits,
+      segments = readiness.segments; // Events name
+
+  var SDK_READY = gate.SDK_READY; // Shared instances use parent metrics collectors
+
+  var metrics = sharedInstance ? undefined : MetricsFactory(context); // Shared instances use parent events queue
+
+  var events = sharedInstance ? undefined : EventsFactory(context);
+  var syncManager;
+
+  switch (settings.mode) {
+    case PRODUCER_MODE:
+    case STANDALONE_MODE:
+      {
+        context.put(context.constants.COLLECTORS, metrics && metrics.collectors); // We don't fully instantiate syncManager if we are creating a shared instance.
+
+        if (sharedInstance) {
+          syncManager = syncManagers[settings.core.authorizationKey].shared(context);
+        } else {
+          syncManager = SyncManagerFactory(context);
+          syncManagers[settings.core.authorizationKey] = syncManager;
+        }
+
+        break;
+      }
+
+    case CONSUMER_MODE:
+      {
+        context.put(context.constants.READY_FROM_CACHE, true); // For SDK inner workings it's supposed to be ready from cache.
+
+        break;
+      }
+  } // Signal listener only needed for main instances
+
+
+  var signalsListener = sharedInstance ? undefined : new SignalsListener(context, syncManager);
+
+  if (readyTrackers && syncManager && !sharedInstance) {
+    // Only track ready events for non-shared and non-consumer clients
+    var sdkReadyTracker = readyTrackers.sdkReadyTracker,
+        splitsReadyTracker = readyTrackers.splitsReadyTracker,
+        segmentsReadyTracker = readyTrackers.segmentsReadyTracker; // Defered setup of collectors for this task, as it is the only ready latency we store on BE.
+
+    sdkReadyTracker.setCollectorForTask(metrics.collectors);
+    gate.once(SDK_READY, sdkReadyTracker);
+    splits.once(splits.SDK_SPLITS_ARRIVED, splitsReadyTracker);
+    segments.once(segments.SDK_SEGMENTS_ARRIVED, segmentsReadyTracker);
+  } // Start background jobs tasks
+
+
+  syncManager && syncManager.start();
+  metrics && metrics.start();
+  events && context.put(context.constants.EVENTS, events) && events.start(); // If no collectors are stored we are on a shared instance, save main one.
+
+  context.put(context.constants.COLLECTORS, mainClientMetricCollectors);
+  var api = objectAssign( // Proto linkage of the EventEmitter to prevent any change
+  Object.create(statusManager), // getTreatment/s & track
+  ClientFactory(context), // Utilities
+  {
+    // Destroy instance
+    destroy: function destroy() {
+      // Stop background jobs
+      syncManager && syncManager.stop();
+      metrics && metrics.stop();
+      events && events.stop(); // Send impressions and events in parallel.
+
+      return Promise.all([metrics && metrics.flush(), events && events.flush()]).then(function () {
+        // Cleanup event listeners
+        readiness.destroy();
+        signalsListener && signalsListener.stop(); // Cleanup storage
+
+        storage.destroy && storage.destroy(); // Mark the factory as destroyed.
+
+        context.put(context.constants.DESTROYED, true); // And release the API Key and SyncManager
+
+        if (!sharedInstance) {
+          releaseApiKey(settings.core.authorizationKey);
+          delete syncManagers[settings.core.authorizationKey];
+        }
+      });
+    }
+  }); // We'll start the signals listener if the client is not a shared instance.
+  // For now, we will only call destroy.
+
+  !sharedInstance && signalsListener.start(api.destroy);
+  return {
+    api: api,
+    metricCollectors: metrics && metrics.collectors
+  };
+}
+
+export default SplitFactoryOnline;