@livedigital/client 3.36.0 → 3.36.2

package/dist/types/socket.d.ts

@@ -6,6 +6,8 @@ export declare enum SocketIOEvents {
     Reconnecting = "reconnecting",
     Reconnected = "reconnected",
     ReconnectAttempt = "reconnect_attempt",
+    ReconnectFailed = "reconnect_failed",
+    ReconnectError = "reconnect_error",
     NeedToJoinFirst = "need_to_join_first",
     Disconnect = "disconnect",
     Disconnected = "disconnected",

package/package.json

@@ -2,7 +2,7 @@
   "name": "@livedigital/client",
   "author": "vlprojects",
   "license": "MIT",
-  "version": "3.36.0",
+  "version": "3.36.2",
   "private": false,
   "bugs": {
     "url": "https://github.com/vlprojects/livedigital-sdk/issues"
@@ -85,7 +85,7 @@
     "@types/sinon-chai": "^3.2.9",
     "@typescript-eslint/eslint-plugin": "^4.32.0",
     "@typescript-eslint/parser": "^4.32.0",
-    "audio-effects-sdk": "^2.4.2",
+    "audio-effects-sdk": "^2.4.3",
     "axios-mock-adapter": "^1.21.2",
     "chai": "^4.3.7",
     "chai-as-promised": "^7.1.1",

package/src/constants/common.ts

@@ -21,3 +21,7 @@ export const PEER_APP_DATA_MAX_SIZE_BYTES = 2048;
 export const SOCKET_ERROR_CODE_UNAUTHORIZED = 'unauthorized';
 
 export const MAX_JOIN_ATTEMPTS = 4;
+
+export const DEBOUNCE_LIMIT = 3;
+
+export const TEN_SECONDS_IN_MS = 10 * 1000;

package/src/engine/index.ts

@@ -596,7 +596,7 @@ class Engine {
       this.channelEventsHandler.subscribeToEvents();
       this.mediaSoupEventsHandler.subscribeToEvents();
       this.state.isJoined = true;
-      this.#logger.debug('Successfully joined channel', { channelId });
+      this.#logger.info('Successfully joined channel', { channelId });
       await this.dataChannelsManager.createAllDataChannels();
       clientMetaProvider.setPeerId(peerId);
       clientMetaProvider.setChannelId(channelId);

package/src/engine/media/index.ts

@@ -359,6 +359,12 @@ class Media {
   }
 
   async fallbackToRNoise(track: AudioTrack, context: DenoiserFallbackContext) {
+    if (this.#denoiserFallbacked) {
+      return;
+    }
+
+    this.#denoiserFallbacked = true;
+
     if (this.#denoiser === 'rnnoise') {
       return;
     }

package/src/engine/media/streamEffects/audio/asdk/ASDKTrackProcessor.ts

@@ -1,8 +1,31 @@
 import { serializeError } from 'serialize-error';
-import type { atsvb, Config } from 'audio-effects-sdk';
+import type { atsvb, Config, ErrorType } from 'audio-effects-sdk';
 import { LoggerFactory } from '../../../../../types/container';
 import Logger from '../../../../Logger';
 import { AudioTrackProcessor } from '../AudioTrackProcessor';
+import { TEN_SECONDS_IN_MS, DEBOUNCE_LIMIT } from '../../../../../constants/common';
+
+declare enum ErrorCode {
+  PERFORMANCE_STOP = 1001,
+  REDUCE_LATENCY = 1002,
+}
+declare enum ErrorEmitter {
+  ATSVB = 'atsvb',
+  STREAM_PROCESSOR = 'stream_processor',
+  ML_INFERENCE = 'ml_inference',
+  MODEL = 'model',
+  WORKLET = 'worklet',
+  WORKER = 'worker',
+  MODEL_LOADER = 'model_loader',
+}
+interface ErrorObject {
+  message: string;
+  type: ErrorType;
+  code?: ErrorCode;
+  emitter?: ErrorEmitter;
+  cause?: Error;
+  data?: any;
+}
 
 declare global {
   interface Window {
@@ -30,6 +53,8 @@ export class ASDKTrackProcessor implements AudioTrackProcessor {
 
   #sampleRate: Config['sampleRate'] = 16000;
 
+  #debounceCounters = new Map<number, number>();
+
   #track?: MediaStreamTrack;
 
   readonly type = 'asdk';
@@ -50,48 +75,12 @@ export class ASDKTrackProcessor implements AudioTrackProcessor {
       sdk_url: 'https://effectssdk.ai/sdk/audio/',
       // path to wasm files
       wasmPaths: {
-        'ort-wasm.wasm': 'https://effectssdk.ai/sdk/audio/dev/2.4.2/ort-wasm.wasm',
-        'ort-wasm-simd.wasm': 'https://effectssdk.ai/sdk/audio/dev/2.4.2/ort-wasm-simd.wasm',
+        'ort-wasm.wasm': 'https://effectssdk.ai/sdk/audio/dev/2.4.3/ort-wasm.wasm',
+        'ort-wasm-simd.wasm': 'https://effectssdk.ai/sdk/audio/dev/2.4.3/ort-wasm-simd.wasm',
       },
     });
 
-    this.#atsvb.onError((error) => {
-      const {
-        message, type, cause, ...rest
-      } = error;
-
-      if (rest.code === 1002 || rest.code === 1001) {
-        this.#onError(`ASDK performance issue(${rest.code}): ${message}`, cause);
-      }
-
-      if (type === 'error') {
-        this.#logger.error(message, {
-          error: serializeError(cause),
-          cause,
-          ...rest,
-          type: this.type,
-          case: 'Denoiser',
-        });
-        this.#onError(`ASDK runtime error: ${message}`, cause);
-        this.#onError = noop;
-      }
-
-      if (type === 'warning') {
-        this.#logger.warn(message, {
-          ...rest,
-          type: this.type,
-          case: 'Denoiser',
-        });
-      }
-
-      if (type === 'info') {
-        this.#logger.info(message, {
-          ...rest,
-          type: this.type,
-          case: 'Denoiser',
-        });
-      }
-    });
+    this.#atsvb.onError(this.onError.bind(this));
   }
 
   setOnError(onError: (reason: string, error: Error | undefined) => void): void {
@@ -142,6 +131,12 @@ export class ASDKTrackProcessor implements AudioTrackProcessor {
 
       const outTrack = await outTrackPromise;
 
+      this.#logger.info('processTrack()', {
+        case: 'Denoiser',
+        type: this.type,
+        track: track.id,
+      });
+
       return outTrack;
     } catch (error) {
       this.#logger.error('processTrack()', {
@@ -171,4 +166,67 @@ export class ASDKTrackProcessor implements AudioTrackProcessor {
       this.#originalTrack = null;
     }
   }
+
+  getUpdatedDebounceCounter(errorCode: number) {
+    let value = this.#debounceCounters.get(errorCode) || 0;
+
+    value += 1;
+    this.#debounceCounters.set(errorCode, value);
+
+    setTimeout(() => {
+      const currentValue = this.#debounceCounters.get(errorCode) || 0;
+      if (currentValue <= 0) {
+        this.#debounceCounters.set(errorCode, 0);
+        return;
+      }
+
+      this.#debounceCounters.set(errorCode, currentValue - 1);
+    }, TEN_SECONDS_IN_MS);
+
+    return value;
+  }
+
+  onError(error: ErrorObject) {
+    const {
+      message, type, cause, ...rest
+    } = error;
+
+    if (type === 'error') {
+      this.#logger.error(message, {
+        error: serializeError(cause),
+        cause,
+        ...rest,
+        type: this.type,
+        case: 'Denoiser',
+      });
+
+      if (rest.code === ErrorCode.REDUCE_LATENCY || rest.code === ErrorCode.PERFORMANCE_STOP) {
+        const debounceCounter = this.getUpdatedDebounceCounter(rest.code);
+        if (debounceCounter > DEBOUNCE_LIMIT) {
+          this.#debounceCounters.set(rest.code, 0);
+          this.#onError(`ASDK performance issue(${rest.code}): ${message}`, cause);
+          this.#onError = noop;
+        }
+      } else {
+        this.#onError(`ASDK runtime error: ${message}`, cause);
+        this.#onError = noop;
+      }
+    }
+
+    if (type === 'warning') {
+      this.#logger.warn(message, {
+        ...rest,
+        type: this.type,
+        case: 'Denoiser',
+      });
+    }
+
+    if (type === 'info') {
+      this.#logger.info(message, {
+        ...rest,
+        type: this.type,
+        case: 'Denoiser',
+      });
+    }
+  }
 }

package/src/engine/network/Socket.ts

@@ -1,4 +1,5 @@
 import { inject, injectable } from 'inversify';
+import { serializeError } from 'serialize-error';
 import { io, Socket } from 'socket.io-client';
 import { SIGNALING_API_VERSION } from '../../constants/common';
 import { MEDIASOUP_MEDIA_ACTIONS_TRACK_EVENTS } from '../../constants/events';
@@ -94,7 +95,9 @@ class SocketIO {
 
     connection.on(SocketIOEvents.ConnectError, (error: unknown) => {
       this.connectionError = error as string;
-      this.#logger.error(`connection.on('${SocketIOEvents.ConnectError}')`, { error });
+      this.#logger.error(`connection.on('${SocketIOEvents.ConnectError}')`, {
+        error: serializeError(error),
+      });
       this.observer.safeEmit(SocketIOEvents.State, { state: SocketIOEvents.Error, error });
 
       if (this.reconnectingAttempt > this.#maxReconnectingAttempts) {
@@ -106,6 +109,13 @@ class SocketIO {
       }
     });
 
+    connection.on(SocketIOEvents.ReconnectError, (error: unknown) => {
+      this.#logger.error(`connection.on('${SocketIOEvents.ReconnectError}')`, {
+        case: 'SocketReconnect',
+        error: serializeError(error),
+      });
+    });
+
     connection.on(SocketIOEvents.Disconnect, ((reason: string) => {
       this.isConnected = false;
       this.setReconnectingAttempt(0);

package/src/helpers/retry.ts

@@ -1,3 +1,4 @@
+import { serializeError } from 'serialize-error';
 import DefaultTimeProvider from './datetime';
 import Logger from '../engine/Logger';
 
@@ -34,7 +35,7 @@ const retryAsync = async <ReturnType>(
         opts.logger.info('Action retry failed', {
           currentAttempt,
           actionName: opts.actionName,
-          error: err,
+          error: serializeError(err),
         });
       }
 

package/src/inversify.factories.ts

@@ -160,12 +160,11 @@ export function audioTrackProcessorFactory(context: interfaces.Context): AudioTr
   return (params: CreateAudioTrackProcessorParams): AudioTrackProcessor => {
     const denoiser = config.get('denoiser');
 
-    if (processorsCache.has(denoiser, params.trackLabel)) {
-      throw new Error(`Track processor for type:${denoiser}, label:${params.trackLabel} already created`);
+    let processor = processorsCache.get(denoiser, params.trackLabel);
+    if (processor) {
+      return processor;
     }
 
-    let processor;
-
     if (denoiser === 'rnnoise' && params.noiseSuppressor) {
       processor = new RNNoiseTrackProcessor({
         noiseSuppressor: params.noiseSuppressor,

package/src/types/socket.ts

@@ -8,6 +8,9 @@ export enum SocketIOEvents {
   Reconnecting = 'reconnecting',
   Reconnected = 'reconnected',
   ReconnectAttempt = 'reconnect_attempt',
+  ReconnectFailed = 'reconnect_failed',
+  ReconnectError = 'reconnect_error',
+
   NeedToJoinFirst = 'need_to_join_first',
 
   Disconnect = 'disconnect',