@featbit/js-client-sdk 2.0.1 → 3.0.0

package/src/events/DefaultEventSender.ts

@@ -0,0 +1,75 @@
+import { DeliveryStatus, IEventSender, IEventSenderResult } from "./IEventSender";
+import ClientContext from "../options/ClientContext";
+import { defaultHeaders, httpErrorMessage } from "../utils/http";
+import { IRequests } from "../platform/requests";
+import { isHttpRecoverable, UnexpectedResponseError } from "../errors";
+import sleep from "../utils/sleep";
+
+export class DefaultEventSender implements IEventSender {
+  private readonly defaultHeaders: {
+    [key: string]: string;
+  };
+  private readonly eventsUri: string;
+  private requests: IRequests;
+
+  constructor(clientContext: ClientContext) {
+    const {
+      sdkKey,
+      eventsUri,
+      platform
+    } = clientContext;
+
+    const {info, requests} = platform;
+    this.defaultHeaders = defaultHeaders(sdkKey, info);
+    this.eventsUri = eventsUri;
+    this.requests = requests;
+  }
+
+  async send(payload: string, retry: boolean): Promise<IEventSenderResult> {
+    const res: IEventSenderResult = {
+      status: DeliveryStatus.Succeeded,
+    };
+
+    const headers: Record<string, string> = {
+      ...this.defaultHeaders,
+      'content-type': 'application/json',
+    }
+
+    let error;
+    try {
+      const {status} = await this.requests.fetch(this.eventsUri, {
+        headers,
+        body: payload,
+        method: 'POST',
+      });
+
+      if (status >= 200 && status <= 299) {
+        return res;
+      }
+
+      error = new UnexpectedResponseError(
+        httpErrorMessage({status, message: 'some events were dropped'}, 'event posting'),
+      );
+
+      if (!isHttpRecoverable(status)) {
+        res.status = DeliveryStatus.FailedAndMustShutDown;
+        res.error = error;
+        return res;
+      }
+    } catch (err) {
+      error = err;
+    }
+
+    // recoverable but not retrying
+    if (error && !retry) {
+      res.status = DeliveryStatus.Failed;
+      res.error = error;
+      return res;
+    }
+
+    // wait 1 second before retrying
+    await sleep();
+
+    return this.send(payload, false);
+  }
+}

package/src/events/DefaultEventSerializer.ts

@@ -0,0 +1,12 @@
+import { IEventSerializer } from "./EventSerializer";
+import { EvalEvent, IEvent, MetricEvent } from "./event";
+
+export class DefaultEventSerializer implements IEventSerializer {
+  serialize(events: IEvent[]): string {
+    const payload = events
+      .map(event => event instanceof EvalEvent || event instanceof MetricEvent ? event.toPayload() : null)
+      .filter(event => event !== null);
+
+    return JSON.stringify(payload);
+  }
+}

package/src/events/EventDispatcher.ts

@@ -0,0 +1,128 @@
+import { ILogger } from "../logging/ILogger";
+import ClientContext from "../options/ClientContext";
+import { DeliveryStatus, IEventSender } from "./IEventSender";
+import { IEventQueue } from "./IEventQueue";
+import { DefaultEventQueue } from "./DefaultEventQueue";
+import { DefaultEventSender } from "./DefaultEventSender";
+import { AsyncEvent, FlushEvent, IEvent, PayloadEvent, ShutdownEvent } from "./event";
+import { IEventSerializer } from "./EventSerializer";
+import { DefaultEventSerializer } from "./DefaultEventSerializer";
+import sleep from "../utils/sleep";
+
+export class EventDispatcher {
+  private readonly logger: ILogger;
+  private sender: IEventSender;
+  private buffer: IEventQueue;
+  private serializer: IEventSerializer;
+
+  private maxEventPerRequest = 50;
+  private stopped: boolean = false;
+
+  constructor(clientContext: ClientContext, queue: IEventQueue) {
+    const {logger, maxEventsInQueue} = clientContext;
+    this.logger = logger!;
+
+    this.buffer = new DefaultEventQueue(maxEventsInQueue, this.logger);
+    this.sender = new DefaultEventSender(clientContext);
+    this.serializer = new DefaultEventSerializer();
+
+    this.dispatchLoop(queue).then();
+  }
+
+  private async dispatchLoop(queue: IEventQueue) {
+    this.logger.debug('Start dispatch loop.');
+
+    let running = true;
+    while (running) {
+      try {
+        const event = queue.shift();
+
+        if (event === undefined) {
+          await sleep(1000);
+          continue;
+        }
+
+        if (event instanceof PayloadEvent) {
+          this.addEventToBuffer(event);
+        } else if (event instanceof FlushEvent) {
+          await this.triggerFlush(event);
+        } else if (event instanceof ShutdownEvent) {
+          await this.triggerFlush(event);
+          this.stopped = true;
+          running = false;
+        }
+      } catch (err) {
+        this.logger.error('Unexpected error in event dispatcher.', err);
+      }
+    }
+
+    this.logger.debug('Finish dispatch loop.');
+  }
+
+  private addEventToBuffer(event: IEvent) {
+    if (this.stopped) {
+      return;
+    }
+
+    if (this.buffer.addEvent(event)) {
+      this.logger.debug('Added event to buffer.');
+    } else {
+      this.logger.warn('Exceeded event queue capacity, event will be dropped. Increase capacity to avoid dropping events.');
+    }
+  }
+
+  private async triggerFlush(event: AsyncEvent) {
+    if (this.stopped) {
+      event.complete();
+      return;
+    }
+
+    if (this.buffer.isEmpty) {
+      event.complete();
+      this.logger.debug('Flush empty buffer.');
+      // There are no events to flush. If we don't complete the message, then the async task may never
+      // complete (if it had a non-zero positive timeout, then it would complete after the timeout).
+      return;
+    }
+
+    const snapshot = this.buffer.eventsSnapshot;
+    this.buffer.clear();
+    try {
+      await this.flushEvents(snapshot);
+      this.logger.debug(`${ snapshot.length } events has been flushed.`);
+    } catch (err) {
+      this.logger.warn('Exception happened when flushing events', err);
+    }
+
+    event.complete();
+  }
+
+  private async flushEvents(events: IEvent[]) {
+    events = this.getUniqueEvents(events);
+    const total = events.length;
+    for (let i = 0; i < total; i += this.maxEventPerRequest) {
+      const length = Math.min(this.maxEventPerRequest, total - i);
+      const slice = events.slice(i, i + length);
+      const payload = this.serializer.serialize(slice);
+
+      const {status} = await this.sender.send(payload, true);
+      if (status === DeliveryStatus.FailedAndMustShutDown) {
+        this.stopped = true;
+      }
+    }
+  }
+
+  private getUniqueEvents(events: IEvent[]): IEvent[] {
+    const uniqueEvents: IEvent[] = [];
+    const hashes: string[] = [];
+
+    for (const event of events) {
+      if (!hashes.includes(event.hash)) {
+        uniqueEvents.push(event);
+        hashes.push(event.hash);
+      }
+    }
+
+    return uniqueEvents;
+  }
+}

package/src/events/EventSerializer.ts

@@ -0,0 +1,5 @@
+import { IEvent } from "./event";
+
+export interface IEventSerializer {
+  serialize(events: IEvent[]): string;
+}

package/src/events/IEventProcessor.ts

@@ -0,0 +1,9 @@
+import { IEvent } from "./event";
+
+export interface IEventProcessor {
+  close(): Promise<void>;
+
+  flush(): Promise<void>;
+
+  record(event: IEvent | null): boolean;
+}

package/src/events/IEventQueue.ts

@@ -0,0 +1,17 @@
+import { IEvent } from "./event";
+
+export interface IEventQueue {
+  addEvent(event: IEvent): boolean;
+
+  clear(): void;
+
+  shift(): IEvent | undefined;
+
+  close(): void;
+
+  get eventsSnapshot(): IEvent[];
+
+  get length(): number;
+
+  get isEmpty(): boolean;
+}

package/src/events/IEventSender.ts

@@ -0,0 +1,14 @@
+export enum DeliveryStatus {
+  Succeeded,
+  Failed,
+  FailedAndMustShutDown
+}
+
+export interface IEventSenderResult {
+  status: DeliveryStatus,
+  error?: any
+}
+
+export interface IEventSender {
+  send(payload: string, retry: boolean): Promise<IEventSenderResult>;
+}

package/src/events/NullEventProcessor.ts

@@ -0,0 +1,16 @@
+import { IEventProcessor } from "./IEventProcessor";
+import { IEvent } from "./event";
+
+export class NullEventProcessor implements IEventProcessor {
+  flush(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  close(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  record(event: IEvent | null): boolean {
+    return false;
+  }
+}

package/src/events/event.ts

@@ -0,0 +1,130 @@
+import { IUser } from "../options/IUser";
+import { IVariation } from "../evaluation/data/IFlag";
+
+export interface IEvent {
+  hash: string;
+}
+
+export class AsyncEvent implements IEvent {
+  private readonly isCompletedPromise?: Promise<AsyncEvent>;
+  private resolveFn?: (value: AsyncEvent) => void;
+  timestamp = (new Date()).getTime();
+
+  get hash(): string {
+    return this.timestamp.toString();
+  }
+
+  constructor() {
+    this.isCompletedPromise = new Promise<AsyncEvent>((resolve) => {
+      this.resolveFn = resolve;
+    });
+  }
+
+  waitForCompletion(): Promise<AsyncEvent> {
+    return this.isCompletedPromise!;
+  }
+
+  complete() {
+    this.resolveFn?.(this);
+  }
+}
+
+export class FlushEvent extends AsyncEvent {
+}
+
+export class ShutdownEvent extends AsyncEvent {
+}
+
+export class PayloadEvent implements IEvent {
+  timestamp = (new Date()).getTime();
+
+  get hash(): string {
+    return this.timestamp.toString();
+  }
+
+  toPayload(): any {
+  };
+}
+
+export class MetricEvent extends PayloadEvent {
+  constructor(
+    public user: IUser,
+    public eventName: string,
+    public appType: string,
+    public metricValue: number
+  ) {
+    super();
+  }
+
+  private userPayload() {
+    return {
+      keyId: this.user.keyId,
+      name: this.user.name,
+      customizedProperties: this.user.customizedProperties
+    }
+  }
+
+  toPayload(): any {
+    return {
+      user: this.userPayload(),
+      metrics: [{
+        route: 'index/metric',
+        timestamp: this.timestamp,
+        numericValue: this.metricValue,
+        appType: this.appType,
+        eventName: this.eventName,
+        type: 'CustomEvent'
+      }]
+    }
+  }
+
+  get hash(): string {
+    const payload = this.toPayload();
+    const hasObject = {
+      user: payload.user,
+      metrics: payload.metrics.map((m: any) => ({...m, timestamp: undefined}))
+    }
+    return JSON.stringify(hasObject);
+  }
+}
+
+export class EvalEvent extends PayloadEvent {
+  constructor(
+    public user: IUser,
+    public flagKey: string,
+    public variation: IVariation,
+    public sendToExperiment: boolean
+  ) {
+    super();
+  }
+
+  private userPayload() {
+    return {
+      keyId: this.user.keyId,
+      name: this.user.name,
+      customizedProperties: this.user.customizedProperties
+    }
+  }
+
+  toPayload(): any {
+    return {
+      user: this.userPayload(),
+      variations: [{
+        featureFlagKey: this.flagKey,
+        sendToExperiment: this.sendToExperiment,
+        timestamp: this.timestamp,
+        variation: this.variation
+      }]
+    }
+  }
+
+  get hash(): string {
+    const payload = this.toPayload();
+    const hasObject = {
+      user: payload.user,
+      variations: payload.variations.map((m: any) => ({...m, timestamp: undefined}))
+    }
+
+    return JSON.stringify(hasObject);
+  }
+}

package/src/events/index.ts

@@ -0,0 +1,11 @@
+export * from './DefaultEventProcessor';
+export * from './DefaultEventQueue';
+export * from './DefaultEventSender';
+export * from './DefaultEventSerializer';
+export * from './event';
+export * from './EventDispatcher';
+export * from './EventSerializer';
+export * from './IEventProcessor';
+export * from './IEventQueue';
+export * from './IEventSender';
+export * from './NullEventProcessor';

package/src/index.ts

@@ -1,6 +1,21 @@
-import fbClient, { FB } from './featbit';
-import { logger } from "./logger";
+export * from './bootstrap';
+export * from './data-sources';
+export * from './evaluation';
+export * from './events';
+export * from './logging';
+export * from './options';
+export * from './platform';
+export * from './store';
+export * from './data-sync';
+export * from './utils';
 
-export * from './types';
+export * from './Configuration';
+export * from './constants';
+export * from './Context';
+export * from './errors';
+export * from './FbClientBuilder';
+export * from './IContextProperty';
+export * from './IDataKind';
+export * from './IFbClient';
+export * from './IVersionedData';
 
-export { FB, fbClient, logger };

package/src/integrations/TestLogger.ts

@@ -0,0 +1,25 @@
+import { ILogger } from "../logging/ILogger";
+
+export class TestLogger implements ILogger {
+  public logs: string[] = [];
+
+  error(...args: any[]): void {
+    this.logs.push(args.join(' '));
+  }
+
+  warn(...args: any[]): void {
+    this.logs.push(args.join(' '));
+  }
+
+  info(...args: any[]): void {
+    this.logs.push(args.join(' '));
+  }
+
+  debug(...args: any[]): void {
+    this.logs.push(args.join(' '));
+  }
+
+  reset() {
+    this.logs = [];
+  }
+}

package/src/integrations/index.ts

@@ -0,0 +1,2 @@
+export * from './test_data';
+export { TestLogger } from './TestLogger';

package/src/integrations/test_data/FlagBuilder.ts

@@ -0,0 +1,60 @@
+// used only by tests
+import { IFlag, VariationDataType, IVariation, FlagValue } from "../../evaluation/data/IFlag";
+
+export class FlagBuilder {
+  private _id: string = `xxxxx-${new Date().getTime()}-xxxxxx`;
+  private _key?: string;
+  private _version?: number;
+  private _variationType: VariationDataType = VariationDataType.empty;
+  private _sendToExperiment: boolean = false;
+  private _variation: FlagValue = '';
+  private _variations: IVariation[] = [];
+
+  id(id: string): FlagBuilder {
+    this._id = id;
+    return this;
+  }
+
+  key(key: string): FlagBuilder {
+    this._key = key;
+    return this;
+  }
+
+  version(version: number): FlagBuilder {
+    this._version = version
+    return this;
+  }
+
+  sendToExperiment(val: boolean): FlagBuilder {
+    this._sendToExperiment = val
+    return this;
+  }
+
+  variation(variation: FlagValue): FlagBuilder {
+    this._variation = variation
+    return this;
+  }
+
+  variationType(variationType: VariationDataType): FlagBuilder {
+    this._variationType = variationType
+    return this;
+  }
+
+  variations(variations: IVariation[]): FlagBuilder {
+    this._variations = variations
+    return this;
+  }
+
+  build(): IFlag {
+    return {
+      id: this._id!,
+      key: this._key!,
+      version: this._version!,
+      variationType: this._variationType,
+      variations: this._variations,
+      sendToExperiment: this._sendToExperiment,
+      variation: this._variation,
+      timestamp: new Date().getTime()
+    };
+  }
+}

package/src/integrations/test_data/TestData.ts

@@ -0,0 +1,58 @@
+import { IFlag } from "../../evaluation/data/IFlag";
+import TestDataSynchronizer from "./TestDataSynchronizer";
+import { IClientContext } from "../../options/IClientContext";
+import { IDataSourceUpdates } from "../../store/IDataSourceUpdates";
+import { VoidFunction } from "../../utils/VoidFunction";
+import { createStreamListeners } from "../../data-sources/createStreamListeners";
+import { IStore } from "../../platform/IStore";
+import DataKinds from "../../store/DataKinds";
+
+export default class TestData {
+  private currentFlags: IFlag[] = [];
+
+  private dataSynchronizer: TestDataSynchronizer | undefined;
+
+  private store: IStore = {} as IStore;
+
+  /**
+   * Get a factory for update processors that will be attached to this TestData instance.
+   * @returns An update processor factory.
+   */
+  getFactory() {
+    // Provides an arrow function to prevent needed to bind the method to
+    // maintain `this`.
+    return (
+      clientContext: IClientContext,
+      store: IStore,
+      dataSourceUpdates: IDataSourceUpdates,
+      initSuccessHandler: VoidFunction,
+      _errorHandler?: (e: Error) => void,
+    ) => {
+      this.store = store;
+
+      const listeners = createStreamListeners(
+        dataSourceUpdates,
+        clientContext.logger,
+        {
+          put: initSuccessHandler,
+        },
+      );
+
+      this.dataSynchronizer = new TestDataSynchronizer(
+        dataSourceUpdates,
+        Object.values(this.currentFlags),
+        () => {},
+        listeners,
+      );
+
+      return this.dataSynchronizer;
+    }
+  }
+
+  update(flag: IFlag): Promise<void> {
+    const oldVersion = this.store.get(DataKinds.Flags, flag.id)?.version || 0;
+    const newFlag = { ...flag, version: oldVersion + 1, key: flag.id };
+
+    return this.dataSynchronizer!.upsert(DataKinds.Flags, newFlag);
+  }
+}

package/src/integrations/test_data/TestDataSynchronizer.ts

@@ -0,0 +1,50 @@
+import { IDataSynchronizer } from "../../data-sync/IDataSynchronizer";
+import { IFlag } from "../../evaluation/data/IFlag";
+import { EventName, ProcessStreamResponse } from "../../data-sync/types";
+import { IDataSourceUpdates } from "../../store/IDataSourceUpdates";
+import { VoidFunction } from "../../utils/VoidFunction";
+import { IDataKind } from "../../IDataKind";
+import { IKeyedStoreItem } from "../../store/store";
+
+export default class TestDataSynchronizer implements IDataSynchronizer {
+  private readonly flags: IFlag[];
+  private readonly userKeyId: string = 'test-user-key-id';
+
+  constructor(
+    private dataSourceUpdates: IDataSourceUpdates,
+    initialFlags: IFlag[],
+    private readonly onStop: VoidFunction,
+    private readonly listeners: Map<EventName, ProcessStreamResponse>
+  ) {
+    // make copies of these objects to decouple them from the originals
+    // so updates made to the originals don't affect these internal data.
+    this.flags = [...initialFlags];
+  }
+
+  async start() {
+    this.listeners.forEach(({deserializeData, processJson }) => {
+      const data = deserializeData(this.flags);
+      processJson(this.userKeyId, data);
+    });
+  }
+
+  identify() {
+    // no-op
+  }
+
+  stop() {
+    this.onStop();
+  }
+
+  close() {
+    this.stop();
+  }
+
+  async upsert(kind: IDataKind, value: IKeyedStoreItem) {
+    return new Promise<void>((resolve) => {
+      this.dataSourceUpdates.upsert(this.userKeyId, kind, value, () => {
+        resolve();
+      });
+    });
+  }
+}

package/src/integrations/test_data/index.ts

@@ -0,0 +1,5 @@
+import TestData from "./TestData";
+import { FlagBuilder } from "./FlagBuilder";
+import TestDataSynchronizer from "./TestDataSynchronizer";
+
+export { TestData, FlagBuilder, TestDataSynchronizer };