@splitsoftware/splitio-commons 2.5.0-rc.0 → 11.5.0-rc.0

package/src/sync/streaming/SSEHandler/NotificationKeeper.ts

@@ -1,107 +0,0 @@
-import { ITelemetryTracker } from '../../../trackers/types';
-import { CONNECTION_ESTABLISHED, DISABLED, ENABLED, OCCUPANCY_PRI, OCCUPANCY_SEC, PAUSED, STREAMING_STATUS } from '../../../utils/constants';
-import { StreamingEventType } from '../../submitters/types';
-import { ControlType, PUSH_SUBSYSTEM_UP, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN } from '../constants';
-import { IPushEventEmitter } from '../types';
-
-const CONTROL_CHANNEL_REGEXS = [/control_pri$/, /control_sec$/];
-const STREAMING_EVENT_TYPES: StreamingEventType[] = [OCCUPANCY_PRI, OCCUPANCY_SEC];
-
-/**
- * Factory of notification keeper, which process OCCUPANCY and CONTROL notifications and emits the corresponding push events.
- *
- * @param pushEmitter - emitter for events related to streaming support
- */
-// @TODO update logic to handle OCCUPANCY for any region and rename according to new spec (e.g.: PUSH_SUBSYSTEM_UP --> PUSH_SUBSYSTEM_UP)
-export function notificationKeeperFactory(pushEmitter: IPushEventEmitter, telemetryTracker: ITelemetryTracker) {
-
-  let channels = CONTROL_CHANNEL_REGEXS.map(regex => ({
-    regex,
-    hasPublishers: true, // keep track of publishers presence per channel, in order to compute `hasPublishers`. Init with true, to emit PUSH_SUBSYSTEM_UP if initial OCCUPANCY notifications have 0 publishers
-    oTime: -1, // keep track of most recent occupancy notification timestamp per channel
-    cTime: -1 // keep track of most recent control notification timestamp per channel
-  }));
-
-  // false if the number of publishers is equal to 0 in all regions
-  let hasPublishers = true;
-
-  // false if last CONTROL event was STREAMING_PAUSED or STREAMING_DISABLED
-  let hasResumed = true;
-
-  function getHasPublishers() { // computes the value of `hasPublishers`
-    return channels.some(c => c.hasPublishers);
-  }
-
-  return {
-    handleOpen() {
-      telemetryTracker.streamingEvent(CONNECTION_ESTABLISHED);
-      pushEmitter.emit(PUSH_SUBSYSTEM_UP);
-    },
-
-    isStreamingUp() {
-      return hasResumed && hasPublishers;
-    },
-
-    handleOccupancyEvent(publishers: number, channel: string, timestamp: number) {
-      for (let i = 0; i < channels.length; i++) {
-        const c = channels[i];
-        if (c.regex.test(channel)) {
-          telemetryTracker.streamingEvent(STREAMING_EVENT_TYPES[i], publishers);
-
-          if (timestamp > c.oTime) {
-            c.oTime = timestamp;
-            c.hasPublishers = publishers !== 0;
-            const hasPublishersNow = getHasPublishers();
-            if (hasResumed) {
-              if (!hasPublishersNow && hasPublishers) {
-                pushEmitter.emit(PUSH_SUBSYSTEM_DOWN);
-              } else if (hasPublishersNow && !hasPublishers) {
-                pushEmitter.emit(PUSH_SUBSYSTEM_UP);
-              }
-              // nothing to do when hasResumed === false:
-              // streaming is already down for `!hasPublishersNow`, and cannot be up for `hasPublishersNow`
-            }
-            hasPublishers = hasPublishersNow;
-          }
-          return;
-        }
-      }
-    },
-
-    handleControlEvent(controlType: ControlType, channel: string, timestamp: number) {
-      /* STREAMING_RESET control event is handled by PushManager directly since it doesn't require
-       * tracking timestamp and state like OCCUPANCY or CONTROL. It also ignores previous
-       * OCCUPANCY and CONTROL notifications, and whether PUSH_SUBSYSTEM_DOWN has been emitted or not */
-      if (controlType === ControlType.STREAMING_RESET) {
-        pushEmitter.emit(controlType);
-        return;
-      }
-
-      for (let i = 0; i < channels.length; i++) {
-        const c = channels[i];
-        if (c.regex.test(channel)) {
-          if (timestamp > c.cTime) {
-            c.cTime = timestamp;
-            if (controlType === ControlType.STREAMING_DISABLED) {
-              telemetryTracker.streamingEvent(STREAMING_STATUS, DISABLED);
-              pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
-            } else if (hasPublishers) {
-              if (controlType === ControlType.STREAMING_PAUSED && hasResumed) {
-                telemetryTracker.streamingEvent(STREAMING_STATUS, PAUSED);
-                pushEmitter.emit(PUSH_SUBSYSTEM_DOWN);
-              } else if (controlType === ControlType.STREAMING_RESUMED && !hasResumed) {
-                telemetryTracker.streamingEvent(STREAMING_STATUS, ENABLED);
-                pushEmitter.emit(PUSH_SUBSYSTEM_UP);
-              }
-              // nothing to do when hasPublishers === false:
-              // streaming is already down for `STREAMING_PAUSED`, and cannot be up for `STREAMING_RESUMED`
-            }
-            hasResumed = controlType === ControlType.STREAMING_RESUMED;
-          }
-          return;
-        }
-      }
-    },
-
-  };
-}

package/src/sync/streaming/SSEHandler/NotificationParser.ts

@@ -1,40 +0,0 @@
-import { OCCUPANCY } from '../constants';
-import { isString } from '../../../utils/lang';
-import { INotificationMessage, INotificationError } from './types';
-
-/**
- * Parses the `data` JSON string, if exists, of a given SSE error notifications.
- * HTTP errors handled by Ably (e.g., 400 due to invalid token, 401 due to expired token, 500) have the `data` property.
- * Other network and HTTP errors do not have this property.
- *
- * @param error - The error event to parse
- * @returns parsed notification error
- * @throws SyntaxError if `error.data` is an invalid JSON string
- */
-export function errorParser(error: Event): INotificationError {
-  // @ts-ignore
-  if (isString(error.data)) error.parsedData = JSON.parse(error.data); // cannot assign to read only property 'data'
-
-  return error;
-}
-
-/**
- * Parses the `data` JSON string of a given SSE message notifications.
- * Also assigns the type OCCUPANCY, if it corresponds, so that all supported messages (e.g., SPLIT_UPDATE, CONTROL) have a type.
- *
- * @param message - The message event to parse
- * @returns parsed notification message or undefined if the given event data is falsy (e.g, '' or undefined).
- * For example, the EventSource implementation of React-Native for iOS emits a message event with empty data for Ably keepalive comments.
- * @throws SyntaxError if `message.data` or `JSON.parse(message.data).data` are invalid JSON strings
- */
-export function messageParser(message: MessageEvent): INotificationMessage | undefined {
-  if (!message.data) return;
-  const messageData = JSON.parse(message.data);
-  messageData.parsedData = JSON.parse(messageData.data);
-
-  // set the event type to OCCUPANCY, to handle all events uniformely
-  if (messageData.name && messageData.name === '[meta]occupancy')
-    messageData.parsedData.type = OCCUPANCY;
-
-  return messageData;
-}

package/src/sync/streaming/SSEHandler/index.ts

@@ -1,105 +0,0 @@
-import { errorParser, messageParser } from './NotificationParser';
-import { notificationKeeperFactory } from './NotificationKeeper';
-import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, RB_SEGMENT_UPDATE } from '../constants';
-import { IPushEventEmitter } from '../types';
-import { ISseEventHandler } from '../SSEClient/types';
-import { INotificationError, INotificationMessage } from './types';
-import { ILogger } from '../../../logger/types';
-import { STREAMING_PARSING_ERROR_FAILS, ERROR_STREAMING_SSE, STREAMING_PARSING_MESSAGE_FAILS, STREAMING_NEW_MESSAGE } from '../../../logger/constants';
-import { ABLY_ERROR, NON_REQUESTED, SSE_CONNECTION_ERROR } from '../../../utils/constants';
-import { ITelemetryTracker } from '../../../trackers/types';
-
-/**
- * Factory for SSEHandler, which processes SSEClient messages and emits the corresponding push events.
- *
- * @param log - factory logger
- * @param pushEmitter - emitter for events related to streaming support
- */
-export function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventEmitter, telemetryTracker: ITelemetryTracker): ISseEventHandler {
-
-  const notificationKeeper = notificationKeeperFactory(pushEmitter, telemetryTracker);
-
-  function isRetryableError(error: INotificationError): boolean {
-    if (error.parsedData && error.parsedData.code) {
-      // Ably error
-      const code = error.parsedData.code;
-      telemetryTracker.streamingEvent(ABLY_ERROR, code);
-
-      // 401 errors due to invalid or expired token (e.g., if refresh token coudn't be executed)
-      if (40140 <= code && code <= 40149) return true;
-      // Others 4XX errors (e.g., bad request from the SDK)
-      if (40000 <= code && code <= 49999) return false;
-    } else {
-      // network errors or 5XX HTTP errors
-      telemetryTracker.streamingEvent(SSE_CONNECTION_ERROR, NON_REQUESTED);
-    }
-    return true;
-  }
-
-  return {
-    handleOpen() {
-      notificationKeeper.handleOpen();
-    },
-
-    /* HTTP & Network errors */
-    handleError(error) {
-      let errorWithParsedData: INotificationError = error;
-      try {
-        errorWithParsedData = errorParser(error);
-      } catch (err) {
-        log.warn(STREAMING_PARSING_ERROR_FAILS, [err]);
-      }
-
-      let errorMessage = (errorWithParsedData.parsedData && errorWithParsedData.parsedData.message) || errorWithParsedData.message;
-      log.error(ERROR_STREAMING_SSE, [errorMessage]);
-
-      if (isRetryableError(errorWithParsedData)) {
-        pushEmitter.emit(PUSH_RETRYABLE_ERROR);
-      } else {
-        pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
-      }
-    },
-
-    /* NotificationProcessor */
-    handleMessage(message) {
-      let messageWithParsedData: INotificationMessage | undefined;
-      try {
-        messageWithParsedData = messageParser(message);
-        if (!messageWithParsedData) return; // Messages with empty data are ignored
-      } catch (err) {
-        log.warn(STREAMING_PARSING_MESSAGE_FAILS, [err]);
-        return;
-      }
-
-      const { parsedData, data, channel, timestamp } = messageWithParsedData;
-      log.debug(STREAMING_NEW_MESSAGE, [data]);
-
-      // we only handle update events if streaming is up
-      if (!notificationKeeper.isStreamingUp() && [OCCUPANCY, CONTROL].indexOf(parsedData.type) === -1) return;
-
-      switch (parsedData.type) {
-        /* update events */
-        case SPLIT_UPDATE:
-        case SEGMENT_UPDATE:
-        case MEMBERSHIPS_MS_UPDATE:
-        case MEMBERSHIPS_LS_UPDATE:
-        case SPLIT_KILL:
-        case RB_SEGMENT_UPDATE:
-          pushEmitter.emit(parsedData.type, parsedData);
-          break;
-
-        /* occupancy & control events, handled by NotificationManagerKeeper */
-        case OCCUPANCY:
-          notificationKeeper.handleOccupancyEvent(parsedData.metrics.publishers, channel, timestamp);
-          break;
-        case CONTROL:
-          notificationKeeper.handleControlEvent(parsedData.controlType, channel, timestamp);
-          break;
-
-        default:
-          break;
-      }
-    },
-
-  };
-}

package/src/sync/streaming/SSEHandler/types.ts

@@ -1,73 +0,0 @@
-import { ControlType } from '../constants';
-import { SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE, RB_SEGMENT_UPDATE } from '../types';
-
-export enum Compression {
-  None = 0,
-  Gzip = 1,
-  Zlib = 2
-}
-
-export enum UpdateStrategy {
-  UnboundedFetchRequest = 0,
-  BoundedFetchRequest = 1,
-  KeyList = 2,
-  SegmentRemoval = 3
-}
-
-export interface KeyList {
-  a?: string[], // decimal hash64 of user keys
-  r?: string[], // decimal hash64 of user keys
-}
-
-interface IMembershipUpdateData<T extends string> {
-  type: T,
-  cn: number,
-  n?: string[],
-  c?: Compression,
-  d?: string,
-  u: UpdateStrategy,
-  i?: number, // time interval in millis
-  h?: number, // hash function
-  s?: number, // seed for hash function
-}
-
-export interface IMembershipMSUpdateData extends IMembershipUpdateData<MEMBERSHIPS_MS_UPDATE> { }
-
-export interface IMembershipLSUpdateData extends IMembershipUpdateData<MEMBERSHIPS_LS_UPDATE> { }
-
-export interface ISegmentUpdateData {
-  type: SEGMENT_UPDATE,
-  changeNumber: number,
-  segmentName: string
-}
-
-export interface ISplitUpdateData {
-  type: SPLIT_UPDATE | RB_SEGMENT_UPDATE,
-  changeNumber: number,
-  pcn?: number,
-  d?: string,
-  c?: Compression
-}
-
-export interface ISplitKillData {
-  type: SPLIT_KILL,
-  changeNumber: number,
-  splitName: string,
-  defaultTreatment: string
-}
-
-export interface IControlData {
-  type: CONTROL,
-  controlType: ControlType
-}
-
-export interface IOccupancyData {
-  type: OCCUPANCY, // Added by `NotificationParser::messageParser` function for consistency with other notification types
-  metrics: {
-    publishers: number
-  }
-}
-
-export type INotificationData = IMembershipMSUpdateData | IMembershipLSUpdateData | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData
-export type INotificationMessage = { parsedData: INotificationData, channel: string, timestamp: number, data: string }
-export type INotificationError = Event & { parsedData?: any, message?: string }

package/src/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.ts

@@ -1,134 +0,0 @@
-import { IMySegmentsSyncTask, MySegmentsData } from '../../polling/types';
-import { Backoff } from '../../../utils/Backoff';
-import { IUpdateWorker } from './types';
-import { ITelemetryTracker } from '../../../trackers/types';
-import { MEMBERSHIPS } from '../../../utils/constants';
-import { IStorageSync } from '../../../storages/types';
-import { ILogger } from '../../../logger/types';
-import { FETCH_BACKOFF_MAX_RETRIES } from './constants';
-import { MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } from '../constants';
-import { AbstractMySegmentsCacheSync } from '../../../storages/AbstractMySegmentsCacheSync';
-
-/**
- * MySegmentsUpdateWorker factory
- */
-export function MySegmentsUpdateWorker(log: ILogger, storage: Pick<IStorageSync, 'segments' | 'largeSegments'>, mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker): IUpdateWorker<[mySegmentsData?: Pick<MySegmentsData, 'type' | 'cn'>, payload?: Pick<MySegmentsData, 'added' | 'removed'>, delay?: number]> {
-
-  let _delay: undefined | number;
-  let _delayTimeoutID: any;
-
-  function createUpdateWorker(mySegmentsCache: AbstractMySegmentsCacheSync) {
-
-    let maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
-    let currentChangeNumber = -1;
-    let handleNewEvent = false;
-    let isHandlingEvent: boolean;
-    let cdnBypass: boolean;
-    let _segmentsData: MySegmentsData | undefined; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
-    const backoff = new Backoff(__handleMySegmentsUpdateCall);
-
-    function __handleMySegmentsUpdateCall() {
-      isHandlingEvent = true;
-      if (maxChangeNumber > Math.max(currentChangeNumber, mySegmentsCache.getChangeNumber())) {
-        handleNewEvent = false;
-        const currentMaxChangeNumber = maxChangeNumber;
-
-        // fetch mySegments revalidating data if cached
-        const syncTask = _delay ?
-          new Promise(res => {
-            _delayTimeoutID = setTimeout(() => {
-              _delay = undefined;
-              mySegmentsSyncTask.execute(_segmentsData, true, cdnBypass ? maxChangeNumber : undefined).then(res);
-            }, _delay);
-          }) :
-          mySegmentsSyncTask.execute(_segmentsData, true, cdnBypass ? maxChangeNumber : undefined);
-
-        syncTask.then((result) => {
-          if (!isHandlingEvent) return; // halt if `stop` has been called
-          if (result !== false) { // Unlike `Splits|SegmentsUpdateWorker`, `mySegmentsCache.getChangeNumber` can be -1, since `/memberships` change number is optional
-            const storageChangeNumber = mySegmentsCache.getChangeNumber();
-            currentChangeNumber = storageChangeNumber > -1 ?
-              storageChangeNumber :
-              Math.max(currentChangeNumber, currentMaxChangeNumber); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
-          }
-          if (handleNewEvent) {
-            __handleMySegmentsUpdateCall();
-          } else {
-            if (_segmentsData) telemetryTracker.trackUpdatesFromSSE(MEMBERSHIPS);
-
-            const attempts = backoff.attempts + 1;
-
-            if (maxChangeNumber <= currentChangeNumber) {
-              log.debug(`Refresh completed${cdnBypass ? ' bypassing the CDN' : ''} in ${attempts} attempts.`);
-              isHandlingEvent = false;
-              return;
-            }
-
-            if (attempts < FETCH_BACKOFF_MAX_RETRIES) {
-              backoff.scheduleCall();
-              return;
-            }
-
-            if (cdnBypass) {
-              log.debug(`No changes fetched after ${attempts} attempts with CDN bypassed.`);
-              isHandlingEvent = false;
-            } else {
-              backoff.reset();
-              cdnBypass = true;
-              __handleMySegmentsUpdateCall();
-            }
-          }
-        });
-      } else {
-        isHandlingEvent = false;
-      }
-    }
-
-    return {
-      /**
-       * Invoked by NotificationProcessor on MY_(LARGE)_SEGMENTS_UPDATE notifications
-       *
-       * @param changeNumber - change number of the notification
-       * @param segmentsData - data for KeyList or SegmentRemoval instant updates
-       * @param delay - optional time to wait for BoundedFetchRequest or BoundedFetchRequest updates
-       */
-      put(mySegmentsData: Pick<MySegmentsData, 'type' | 'cn'>, payload?: Pick<MySegmentsData, 'added' | 'removed'>, delay?: number) {
-        const { type, cn } = mySegmentsData;
-        // Discard event if it is outdated or there is a pending fetch request (_delay is set), but update target change number
-        if (cn <= Math.max(currentChangeNumber, mySegmentsCache.getChangeNumber()) || cn <= maxChangeNumber) return;
-        maxChangeNumber = cn;
-        if (_delay) return;
-
-        handleNewEvent = true;
-        cdnBypass = false;
-        _segmentsData = payload && { type, cn, added: payload.added, removed: payload.removed };
-        _delay = delay;
-
-        if (backoff.timeoutID || !isHandlingEvent) __handleMySegmentsUpdateCall();
-        backoff.reset();
-      },
-
-      stop() {
-        clearTimeout(_delayTimeoutID);
-        _delay = undefined;
-        isHandlingEvent = false;
-        backoff.reset();
-      }
-    };
-  }
-
-  const updateWorkers = {
-    [MEMBERSHIPS_MS_UPDATE]: createUpdateWorker(storage.segments as AbstractMySegmentsCacheSync),
-    [MEMBERSHIPS_LS_UPDATE]: createUpdateWorker(storage.largeSegments as AbstractMySegmentsCacheSync),
-  };
-
-  return {
-    put(mySegmentsData: Pick<MySegmentsData, 'type' | 'cn'>, payload?: Pick<MySegmentsData, 'added' | 'removed'>, delay?: number) {
-      updateWorkers[mySegmentsData.type].put(mySegmentsData, payload, delay);
-    },
-    stop() {
-      updateWorkers[MEMBERSHIPS_MS_UPDATE].stop();
-      updateWorkers[MEMBERSHIPS_LS_UPDATE].stop();
-    }
-  };
-}

package/src/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.ts

@@ -1,99 +0,0 @@
-import { ILogger } from '../../../logger/types';
-import { ISegmentsCacheSync } from '../../../storages/types';
-import { Backoff } from '../../../utils/Backoff';
-import { ISegmentsSyncTask } from '../../polling/types';
-import { ISegmentUpdateData } from '../SSEHandler/types';
-import { FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_RETRIES, FETCH_BACKOFF_MAX_WAIT } from './constants';
-import { IUpdateWorker } from './types';
-
-/**
- * SegmentsUpdateWorker factory
- */
-export function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync): IUpdateWorker<[ISegmentUpdateData]> {
-
-  // Handles retries with CDN bypass per segment name
-  function SegmentUpdateWorker(segment: string) {
-    let maxChangeNumber = 0;
-    let handleNewEvent = false;
-    let isHandlingEvent: boolean;
-    let cdnBypass: boolean;
-    const backoff = new Backoff(__handleSegmentUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
-
-    function __handleSegmentUpdateCall() {
-      isHandlingEvent = true;
-      if (maxChangeNumber > (segmentsCache.getChangeNumber(segment) || -1)) {
-        handleNewEvent = false;
-
-        // fetch segments revalidating data if cached
-        segmentsSyncTask.execute(false, segment, true, cdnBypass ? maxChangeNumber : undefined).then(() => {
-          if (!isHandlingEvent) return; // halt if `stop` has been called
-          if (handleNewEvent) {
-            __handleSegmentUpdateCall();
-          } else {
-            const attempts = backoff.attempts + 1;
-
-            if (maxChangeNumber <= (segmentsCache.getChangeNumber(segment) || -1)) {
-              log.debug(`Refresh completed${cdnBypass ? ' bypassing the CDN' : ''} in ${attempts} attempts.`);
-              isHandlingEvent = false;
-              return;
-            }
-
-            if (attempts < FETCH_BACKOFF_MAX_RETRIES) {
-              backoff.scheduleCall();
-              return;
-            }
-
-            if (cdnBypass) {
-              log.debug(`No changes fetched after ${attempts} attempts with CDN bypassed.`);
-              isHandlingEvent = false;
-            } else {
-              backoff.reset();
-              cdnBypass = true;
-              __handleSegmentUpdateCall();
-            }
-          }
-        });
-      } else {
-        isHandlingEvent = false;
-      }
-    }
-
-    return {
-      put(changeNumber: number) {
-        const currentChangeNumber = segmentsCache.getChangeNumber(segment) || -1;
-
-        if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber) return;
-
-        maxChangeNumber = changeNumber;
-        handleNewEvent = true;
-        cdnBypass = false;
-
-        if (backoff.timeoutID || !isHandlingEvent) __handleSegmentUpdateCall();
-        backoff.reset();
-      },
-      stop() {
-        isHandlingEvent = false;
-        backoff.reset();
-      }
-    };
-  }
-
-  const segments: Record<string, ReturnType<typeof SegmentUpdateWorker>> = {};
-
-  return {
-    /**
-     * Invoked by NotificationProcessor on SEGMENT_UPDATE event
-     *
-     * @param changeNumber - change number of the SEGMENT_UPDATE notification
-     * @param segmentName - segment name of the SEGMENT_UPDATE notification
-     */
-    put({ changeNumber, segmentName }: ISegmentUpdateData) {
-      if (!segments[segmentName]) segments[segmentName] = SegmentUpdateWorker(segmentName);
-      segments[segmentName].put(changeNumber);
-    },
-
-    stop() {
-      Object.keys(segments).forEach(segmentName => segments[segmentName].stop());
-    }
-  };
-}