@featbit/js-client-sdk 3.0.11 → 3.0.13

package/src/events/DefaultEventSender.ts

@@ -1,74 +1,74 @@
-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,
-    }
-
-    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);
-  }
+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,
+    }
+
+    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

@@ -1,12 +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);
-  }
+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

@@ -1,128 +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;
-  }
+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

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

package/src/events/IEventProcessor.ts

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

package/src/events/IEventQueue.ts

@@ -1,17 +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;
+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

@@ -1,14 +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>;
+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

@@ -1,16 +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;
-  }
+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;
+  }
 }