stream-chat 4.3.0 → 4.4.2

package/src/client.ts

@@ -118,6 +118,7 @@ import {
   DeleteChannelsResponse,
   TaskResponse,
 } from './types';
+import { InsightTypes, InsightMetrics } from './insights';
 
 function isString(x: unknown): x is string {
   return typeof x === 'string' || x instanceof String;
@@ -197,6 +198,7 @@ export class StreamChat<
   wsConnection: StableWSConnection<ChannelType, CommandType, UserType> | null;
   wsPromise: ConnectAPIResponse<ChannelType, CommandType, UserType> | null;
   consecutiveFailures: number;
+  insightMetrics: InsightMetrics;
 
   /**
    * Initialize a client
@@ -291,6 +293,7 @@ export class StreamChat<
     // generated from secret.
     this.tokenManager = new TokenManager(this.secret);
     this.consecutiveFailures = 0;
+    this.insightMetrics = new InsightMetrics();
 
     /**
      * logger function should accept 3 parameters:
@@ -1617,6 +1620,7 @@ export class StreamChat<
     }
 
     // The StableWSConnection handles all the reconnection logic.
+
     this.wsConnection = new StableWSConnection<ChannelType, CommandType, UserType>({
       wsBaseURL: client.wsBaseURL,
       clientID: client.clientID,
@@ -1631,6 +1635,8 @@ export class StreamChat<
       eventCallback: this.dispatchEvent as (event: ConnectionChangeEvent) => void,
       logger: this.logger,
       device: this.options.device,
+      postInsights: this.options.enableInsights ? this.postInsights : undefined,
+      insightMetrics: this.insightMetrics,
     });
 
     let warmUpPromise;
@@ -3343,6 +3349,27 @@ export class StreamChat<
     );
   }
 
+  postInsights = async (insightType: InsightTypes, insights: Record<string, unknown>) => {
+    const maxAttempts = 3;
+    for (let i = 0; i < maxAttempts; i++) {
+      try {
+        await this.axiosInstance.post(
+          `https://insights.stream-io-api.com/insights/${insightType}`,
+          insights,
+        );
+      } catch (e) {
+        this.logger('warn', `failed to send insights event ${insightType}`, {
+          tags: ['insights', 'connection'],
+          error: e,
+          insights,
+        });
+        await sleep((i + 1) * 3000);
+        continue;
+      }
+      break;
+    }
+  };
+
   /**
    * deleteUsers - Batch Delete Users
    *

package/src/connection.ts

@@ -1,6 +1,12 @@
 import WebSocket from 'isomorphic-ws';
-import { chatCodes, sleep, retryInterval } from './utils';
+import { chatCodes, sleep, retryInterval, randomId } from './utils';
 import { TokenManager } from './token_manager';
+import {
+  buildWsFatalInsight,
+  buildWsSuccessAfterFailureInsight,
+  InsightMetrics,
+  InsightTypes,
+} from './insights';
 import {
   BaseDeviceFields,
   ConnectAPIResponse,
@@ -30,6 +36,7 @@ type Constructor<
   authType: 'anonymous' | 'jwt';
   clientID: string;
   eventCallback: (event: ConnectionChangeEvent) => void;
+  insightMetrics: InsightMetrics;
   logger: Logger | (() => void);
   messageCallback: (messageEvent: WebSocket.MessageEvent) => void;
   recoverCallback: (
@@ -41,6 +48,7 @@ type Constructor<
   userID: string;
   wsBaseURL: string;
   device?: BaseDeviceFields;
+  postInsights?: (eventType: InsightTypes, event: Record<string, unknown>) => void;
 };
 
 /**
@@ -78,7 +86,6 @@ export class StableWSConnection<
   userID: Constructor<ChannelType, CommandType, UserType>['userID'];
   wsBaseURL: Constructor<ChannelType, CommandType, UserType>['wsBaseURL'];
   device: Constructor<ChannelType, CommandType, UserType>['device'];
-
   connectionID?: string;
   connectionOpen?: ConnectAPIResponse<ChannelType, CommandType, UserType>;
   consecutiveFailures: number;
@@ -97,11 +104,14 @@ export class StableWSConnection<
       StatusCode?: string | number;
     },
   ) => void;
+  requestID: string | undefined;
+  connectionStartTimestamp: number | undefined;
   resolvePromise?: (value: WebSocket.MessageEvent) => void;
   totalFailures: number;
   ws?: WebSocket;
   wsID: number;
-
+  postInsights?: Constructor<ChannelType, CommandType, UserType>['postInsights'];
+  insightMetrics: InsightMetrics;
   constructor({
     apiKey,
     authType,
@@ -116,6 +126,8 @@ export class StableWSConnection<
     userID,
     wsBaseURL,
     device,
+    postInsights,
+    insightMetrics,
   }: Constructor<ChannelType, CommandType, UserType>) {
     this.wsBaseURL = wsBaseURL;
     this.clientID = clientID;
@@ -149,6 +161,8 @@ export class StableWSConnection<
     this.pingInterval = 25 * 1000;
     this.connectionCheckTimeout = this.pingInterval + 10 * 1000;
     this._listenForConnectionChanges();
+    this.postInsights = postInsights;
+    this.insightMetrics = insightMetrics;
   }
 
   /**
@@ -244,13 +258,19 @@ export class StableWSConnection<
     ]);
   }
 
-  _buildUrl = () => {
+  /**
+   * Builds and returns the url for websocket.
+   * @param reqID Unique identifier generated on client side, to help tracking apis on backend.
+   * @returns url string
+   */
+  _buildUrl = (reqID?: string) => {
     const params = {
       user_id: this.user.id,
       user_details: this.user,
       user_token: this.tokenManager.getToken(),
       server_determines_connection_id: true,
       device: this.device,
+      request_id: reqID,
     };
     const qs = encodeURIComponent(JSON.stringify(params));
     const token = this.tokenManager.getToken();
@@ -352,11 +372,12 @@ export class StableWSConnection<
   async _connect() {
     if (this.isConnecting) return; // simply ignore _connect if it's currently trying to connect
     this.isConnecting = true;
-
+    this.requestID = randomId();
+    this.insightMetrics.connectionStartTimestamp = new Date().getTime();
     try {
       await this.tokenManager.tokenReady();
       this._setupConnectionPromise();
-      const wsURL = this._buildUrl();
+      const wsURL = this._buildUrl(this.requestID);
       this.ws = new WebSocket(wsURL);
       this.ws.onopen = this.onopen.bind(this, this.wsID);
       this.ws.onclose = this.onclose.bind(this, this.wsID);
@@ -367,6 +388,13 @@ export class StableWSConnection<
 
       if (response) {
         this.connectionID = response.connection_id;
+        if (this.insightMetrics.wsConsecutiveFailures > 0) {
+          this.postInsights?.(
+            'ws_success_after_failure',
+            buildWsSuccessAfterFailureInsight(this),
+          );
+          this.insightMetrics.wsConsecutiveFailures = 0;
+        }
         return response;
       }
     } catch (err) {
@@ -559,6 +587,12 @@ export class StableWSConnection<
   };
 
   onclose = (wsID: number, event: WebSocket.CloseEvent) => {
+    if (event.code !== chatCodes.WS_CLOSED_SUCCESS) {
+      this.insightMetrics.wsConsecutiveFailures++;
+      this.insightMetrics.wsTotalFailures++;
+      this.postInsights?.('ws_fatal', buildWsFatalInsight(this, event));
+    }
+
     this.logger('info', 'connection:onclose() - onclose callback - ' + event.code, {
       tags: ['connection'],
       event,
@@ -791,7 +825,6 @@ export class StableWSConnection<
         {
           type: 'health.check',
           client_id: this.clientID,
-          user_id: this.userID,
         },
       ];
       // try to send on the connection

package/src/index.ts

@@ -8,5 +8,6 @@ export * from './events';
 export * from './permissions';
 export * from './signing';
 export * from './token_manager';
+export * from './insights';
 export * from './types';
 export { isOwnUser, chatCodes, logChatPromiseExecution } from './utils';

package/src/insights.ts

@@ -0,0 +1,72 @@
+import { StableWSConnection } from './connection';
+import WebSocket from 'isomorphic-ws';
+import { LiteralStringForUnion, UnknownType } from './types';
+import { randomId } from './utils';
+
+export type InsightTypes = 'ws_fatal' | 'ws_success_after_failure';
+export class InsightMetrics {
+  connectionStartTimestamp: number | null;
+  wsConsecutiveFailures: number;
+  wsTotalFailures: number;
+  instanceClientId: string;
+
+  constructor() {
+    this.connectionStartTimestamp = null;
+    this.wsTotalFailures = 0;
+    this.wsConsecutiveFailures = 0;
+    this.instanceClientId = randomId();
+  }
+}
+
+export function buildWsFatalInsight<
+  ChannelType extends UnknownType = UnknownType,
+  CommandType extends string = LiteralStringForUnion,
+  UserType extends UnknownType = UnknownType
+>(
+  connection: StableWSConnection<ChannelType, CommandType, UserType>,
+  event: WebSocket.CloseEvent,
+) {
+  return {
+    err: {
+      wasClean: event.wasClean,
+      code: event.code,
+      reason: event.reason,
+    },
+    ...buildWsBaseInsight(connection),
+  };
+}
+
+function buildWsBaseInsight<
+  ChannelType extends UnknownType = UnknownType,
+  CommandType extends string = LiteralStringForUnion,
+  UserType extends UnknownType = UnknownType
+>(connection: StableWSConnection<ChannelType, CommandType, UserType>) {
+  return {
+    ready_state: connection.ws?.readyState,
+    url: connection._buildUrl(connection.requestID),
+    api_key: connection.apiKey,
+    start_ts: connection.insightMetrics.connectionStartTimestamp,
+    end_ts: new Date().getTime(),
+    auth_type: connection.authType,
+    token: connection.tokenManager.token,
+    user_id: connection.userID,
+    user_details: connection.user,
+    device: connection.device,
+    client_id: connection.connectionID,
+    ws_details: connection.ws,
+    ws_consecutive_failures: connection.insightMetrics.wsConsecutiveFailures,
+    ws_total_failures: connection.insightMetrics.wsTotalFailures,
+    request_id: connection.requestID,
+    online: typeof navigator !== 'undefined' ? navigator?.onLine : null,
+    user_agent: typeof navigator !== 'undefined' ? navigator?.userAgent : null,
+    instance_client_id: connection.insightMetrics.instanceClientId,
+  };
+}
+
+export function buildWsSuccessAfterFailureInsight<
+  ChannelType extends UnknownType = UnknownType,
+  CommandType extends string = LiteralStringForUnion,
+  UserType extends UnknownType = UnknownType
+>(connection: StableWSConnection<ChannelType, CommandType, UserType>) {
+  return buildWsBaseInsight(connection);
+}

package/src/types.ts

@@ -69,6 +69,7 @@ export type AppSettingsAPIResponse<
         mutes?: boolean;
         name?: string;
         push_notifications?: boolean;
+        quotes?: boolean;
         reactions?: boolean;
         read_events?: boolean;
         replies?: boolean;
@@ -859,6 +860,7 @@ export type CreateChannelOptions<CommandType extends string = LiteralStringForUn
   name?: string;
   permissions?: PermissionObject[];
   push_notifications?: boolean;
+  quotes?: boolean;
   reactions?: boolean;
   read_events?: boolean;
   replies?: boolean;
@@ -995,6 +997,7 @@ export type StreamChatOptions = AxiosRequestConfig & {
   baseURL?: string;
   browser?: boolean;
   device?: BaseDeviceFields;
+  enableInsights?: boolean;
   logger?: Logger;
   /**
    * When network is recovered, we re-query the active channels on client. But in single query, you can recover
@@ -1631,6 +1634,7 @@ export type ChannelConfigFields = {
   mutes?: boolean;
   name?: string;
   push_notifications?: boolean;
+  quotes?: boolean;
   reactions?: boolean;
   read_events?: boolean;
   replies?: boolean;
@@ -1699,7 +1703,6 @@ export type PushProvider = 'apn' | 'firebase' | 'huawei';
 export type CommandVariants<CommandType extends string = LiteralStringForUnion> =
   | 'all'
   | 'ban'
-  | 'flag'
   | 'fun_set'
   | 'giphy'
   | 'imgur'

package/src/utils.ts

@@ -144,12 +144,57 @@ export function retryInterval(numberOfFailures: number) {
   return Math.floor(Math.random() * (max - min) + min);
 }
 
-/** adopted from https://github.com/ai/nanoid/blob/master/non-secure/index.js */
-const alphabet = 'ModuleSymbhasOwnPr0123456789ABCDEFGHNRVfgctiUvzKqYTJkLxpZXIjQW';
 export function randomId() {
-  let id = '';
-  for (let i = 0; i < 21; i++) {
-    id += alphabet[(Math.random() * 64) | 0];
+  return generateUUIDv4();
+}
+
+function hex(bytes: Uint8Array): string {
+  let s = '';
+  for (let i = 0; i < bytes.length; i++) {
+    s += bytes[i].toString(16).padStart(2, '0');
   }
-  return id;
+  return s;
+}
+
+// https://tools.ietf.org/html/rfc4122
+export function generateUUIDv4() {
+  const bytes = getRandomBytes(16);
+  bytes[6] = (bytes[6] & 0x0f) | 0x40; // version
+  bytes[8] = (bytes[8] & 0xbf) | 0x80; // variant
+
+  return (
+    hex(bytes.subarray(0, 4)) +
+    '-' +
+    hex(bytes.subarray(4, 6)) +
+    '-' +
+    hex(bytes.subarray(6, 8)) +
+    '-' +
+    hex(bytes.subarray(8, 10)) +
+    '-' +
+    hex(bytes.subarray(10, 16))
+  );
+}
+
+function getRandomValuesWithMathRandom(bytes: Uint8Array): void {
+  const max = Math.pow(2, (8 * bytes.byteLength) / bytes.length);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = Math.random() * max;
+  }
+}
+declare const msCrypto: Crypto;
+
+const getRandomValues = (() => {
+  if (typeof crypto !== 'undefined') {
+    return crypto.getRandomValues.bind(crypto);
+  } else if (typeof msCrypto !== 'undefined') {
+    return msCrypto.getRandomValues.bind(msCrypto);
+  } else {
+    return getRandomValuesWithMathRandom;
+  }
+})();
+
+function getRandomBytes(length: number): Uint8Array {
+  const bytes = new Uint8Array(length);
+  getRandomValues(bytes);
+  return bytes;
 }