@livedigital/client 2.12.0 → 2.13.0

package/dist/types/common.d.ts

@@ -203,3 +203,4 @@ export declare type RemoteConsumerOptions = ConsumerOptions & {
     producerPaused: boolean;
 };
 export declare type LogMessageHandler = (msg: any, ...meta: any) => void;
+export declare type LogLevel = 3 | 4 | 6 | 7;

package/dist/types/engine.d.ts

@@ -7,17 +7,27 @@ import ChannelEventHandler from '../engine/handlers/ChannelEventHandler';
 import MediaSoupEventHandler from '../engine/handlers/MediaSoupEventHandler';
 import WebRTCIssueDetector from '../engine/wid/WebRTCIssueDetector';
 import { LoadBalancerApiClientParams } from '../engine/network/LoadBalancerClient';
-import Logger from '../engine/Logger';
+import { IssueDetectorResult } from '../engine/wid/types';
+import { LogLevel } from './common';
+export declare type IssuesHandler = (issues: IssueDetectorResult) => void;
 export interface CreateIssueDetectorParams {
-    logger: Logger;
+    onIssues?: IssuesHandler;
+}
+export interface CreateMediaParams {
+    logLevel: LogLevel;
 }
 export interface CreateNetworkParams {
+    logLevel: LogLevel;
     loadbalancer: LoadBalancerApiClientParams;
 }
+export interface CreateSystemParams {
+    logLevel: LogLevel;
+    clientEventEmitter: EnhancedEventEmitter;
+}
 export interface EngineDependenciesFactory {
-    createSystem: (clientEventEmitter: EnhancedEventEmitter) => System;
-    createMedia: () => Media;
-    createNetwork: (networkParams: CreateNetworkParams) => Network;
+    createSystem: (params: CreateSystemParams) => System;
+    createMedia: (params: CreateMediaParams) => Media;
+    createNetwork: (params: CreateNetworkParams) => Network;
     createChannelEventHandler: (engine: Engine) => ChannelEventHandler;
     createMediaSoupEventHandler: (engine: Engine) => MediaSoupEventHandler;
     createIssueDetector: (params: CreateIssueDetectorParams) => WebRTCIssueDetector;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@livedigital/client",
   "author": "vlprojects",
   "license": "MIT",
-  "version": "2.12.0",
+  "version": "2.13.0",
   "private": false,
   "bugs": {
     "url": "https://github.com/vlprojects/livedigital-sdk/issues"

package/src/constants/common.ts

@@ -0,0 +1,13 @@
+import { LogLevel } from '../types/common';
+
+export const LOG_LEVEL_ERROR: LogLevel = 3;
+export const LOG_LEVEL_WARN: LogLevel = 4;
+export const LOG_LEVEL_INFO: LogLevel = 6;
+export const LOG_LEVEL_DEBUG: LogLevel = 7;
+
+export const LogLevels = {
+  Error: LOG_LEVEL_ERROR,
+  Warn: LOG_LEVEL_WARN,
+  Info: LOG_LEVEL_INFO,
+  Debug: LOG_LEVEL_DEBUG,
+};

package/src/engine/DefaultEngineDependenciesFactory.ts

@@ -1,4 +1,3 @@
-import EnhancedEventEmitter from '../EnhancedEventEmitter';
 import Network from './network';
 import System from './system';
 import Media from './media';
@@ -6,25 +5,35 @@ import ChannelEventHandler from './handlers/ChannelEventHandler';
 import Engine from './index';
 import MediaSoupEventHandler from './handlers/MediaSoupEventHandler';
 import WebRTCIssueDetector from './wid/WebRTCIssueDetector';
-import { CreateIssueDetectorParams, CreateNetworkParams, EngineDependenciesFactory } from '../types/engine';
+import {
+  CreateIssueDetectorParams,
+  CreateMediaParams,
+  CreateNetworkParams,
+  CreateSystemParams,
+  EngineDependenciesFactory,
+} from '../types/engine';
 import SocketIO from './network/Socket';
 import LoadBalancerApiClient from './network/LoadBalancerClient';
 
 /* eslint-disable class-methods-use-this */
 class DefaultEngineDependenciesFactory implements EngineDependenciesFactory {
-  createSystem(clientEventEmitter: EnhancedEventEmitter): System {
-    return new System({ clientEventEmitter });
+  createSystem(params: CreateSystemParams): System {
+    return new System(params);
   }
 
-  createMedia(): Media {
-    return new Media();
+  createMedia(params: CreateMediaParams): Media {
+    return new Media(params);
   }
 
   createNetwork(params: CreateNetworkParams): Network {
-    const { loadbalancer } = params;
-    const socketClient = new SocketIO();
+    const { loadbalancer, logLevel } = params;
+    const socketClient = new SocketIO({
+      logLevel,
+    });
+
     const loadBalancerApiClient = new LoadBalancerApiClient(loadbalancer);
     return new Network({
+      logLevel,
       socketClient,
       loadBalancerApiClient,
     });
@@ -40,11 +49,7 @@ class DefaultEngineDependenciesFactory implements EngineDependenciesFactory {
 
   createIssueDetector(params: CreateIssueDetectorParams): WebRTCIssueDetector {
     return new WebRTCIssueDetector({
-      onIssue: (issues: any[]) => {
-        issues.forEach((issue) => {
-          params.logger.warn('webRtcIssueDetector', issue);
-        });
-      },
+      onIssues: params.onIssues,
     });
   }
 }

package/src/engine/Logger.ts

@@ -1,35 +1,48 @@
 import debug from 'debug';
-import { LogMessageHandler } from '../types/common';
+import { LogLevels } from '../constants/common';
+import { LogLevel, LogMessageHandler } from '../types/common';
 
 const APP_NAME = 'LiveDigital';
 
+export type LoggerConstructorParams = {
+  namespace: string,
+  logLevel: LogLevel,
+  onLogMessage?: LogMessageHandler,
+};
+
 class Logger {
   private readonly _debug: debug.Debugger;
 
+  private readonly _info: debug.Debugger;
+
   private readonly _warn: debug.Debugger;
 
   private readonly _error: debug.Debugger;
 
-  private readonly onLogMessage: LogMessageHandler;
-
-  constructor(prefix?: string, onLogMessage?: LogMessageHandler) {
-    if (prefix) {
-      this._debug = debug(`${APP_NAME}:${prefix}`);
-      this._warn = debug(`${APP_NAME}:WARN:${prefix}`);
-      this._error = debug(`${APP_NAME}:ERROR:${prefix}`);
-    } else {
-      this._debug = debug(APP_NAME);
-      this._warn = debug(`${APP_NAME}:WARN`);
-      this._error = debug(`${APP_NAME}:ERROR`);
-    }
+  #namespace: string;
+
+  #logLevel: LogLevel;
+
+  #onLogMessage: LogMessageHandler;
+
+  constructor(params: LoggerConstructorParams) {
+    const { logLevel, namespace, onLogMessage } = params;
+    this.#namespace = namespace;
+    this.#logLevel = logLevel;
+
+    this._debug = debug(APP_NAME).extend('debug').extend(this.#namespace);
+    this._info = debug(APP_NAME).extend('info').extend(this.#namespace);
+    this._warn = debug(APP_NAME).extend('warn').extend(this.#namespace);
+    this._error = debug(APP_NAME).extend('error').extend(this.#namespace);
 
     /* eslint-disable no-console */
     this._debug.log = console.info.bind(console);
+    this._info.log = console.info.bind(console);
     this._warn.log = console.warn.bind(console);
     this._error.log = console.error.bind(console);
     /* eslint-enable no-console */
 
-    this.onLogMessage = (msg: any, ...meta: any[]) => {
+    this.#onLogMessage = (msg: any, ...meta: any[]) => {
       if (typeof onLogMessage === 'function') {
         onLogMessage(msg, ...meta);
       }
@@ -38,17 +51,30 @@ class Logger {
 
   debug(msg: any, ...meta: any[]): void {
     this._debug(msg, ...meta);
-    this.onLogMessage(msg, ...meta);
+    if (this.#logLevel >= LogLevels.Debug) {
+      this.#onLogMessage(msg, ...meta);
+    }
+  }
+
+  info(msg: any, ...meta: any[]): void {
+    this._debug(msg, ...meta);
+    if (this.#logLevel >= LogLevels.Info) {
+      this.#onLogMessage(msg, ...meta);
+    }
   }
 
   warn(msg: any, ...meta: any[]): void {
     this._warn(msg, ...meta);
-    this.onLogMessage(msg, ...meta);
+    if (this.#logLevel >= LogLevels.Warn) {
+      this.#onLogMessage(msg, ...meta);
+    }
   }
 
   error(msg: any, ...meta: any[]): void {
     this._error(msg, ...meta);
-    this.onLogMessage(msg, ...meta);
+    if (this.#logLevel >= LogLevels.Error) {
+      this.#onLogMessage(msg, ...meta);
+    }
   }
 }
 

package/src/engine/Peer.ts

@@ -89,7 +89,10 @@ class Peer {
     this.uid = uid;
     this.role = role;
     this.engine = engine;
-    this.logger = new Logger('Peer');
+    this.logger = new Logger({
+      logLevel: engine.logLevel,
+      namespace: 'Peer',
+    });
     producers.forEach(this.handleNewProducer.bind(this));
     this.handlePeerEvents();
   }
@@ -155,7 +158,10 @@ class Peer {
       const track = new PeerTrack({
         mediaStreamTrack: consumer.track,
         label: producer.label,
-        consumer: new PeerConsumer(consumer),
+        consumer: new PeerConsumer({
+          consumer,
+          logLevel: this.engine.logLevel,
+        }),
         engine: this.engine,
         isPaused: remoteConsumer.producerPaused,
         peerEventEmitter: this.observer,

package/src/engine/PeerConsumer.ts

@@ -1,9 +1,14 @@
 import { parseScalabilityMode } from 'mediasoup-client';
 import { MediaKind, RtpEncodingParameters } from 'mediasoup-client/lib/RtpParameters';
 import { Consumer as MediasoupConsumer } from 'mediasoup-client/lib/types';
-import { ConsumerData, SpatialLayerParams } from '../types/common';
+import { ConsumerData, LogLevel, SpatialLayerParams } from '../types/common';
 import Logger from './Logger';
 
+export type PeerConsumerConstructorParams = {
+  consumer: MediasoupConsumer,
+  logLevel: LogLevel,
+};
+
 class PeerConsumer {
   public score = 10;
 
@@ -37,13 +42,17 @@ class PeerConsumer {
 
   private readonly logger: Logger;
 
-  constructor(consumer: MediasoupConsumer) {
+  constructor(params: PeerConsumerConstructorParams) {
+    const { logLevel, consumer } = params;
     this.id = consumer.id;
     this.kind = consumer.kind as MediaKind;
     this.producerId = consumer.producerId;
     this.appData = consumer.appData as ConsumerData;
     this.consumer = consumer;
-    this.logger = new Logger('PeerConsumer');
+    this.logger = new Logger({
+      logLevel,
+      namespace: 'PeerConsumer',
+    });
     this.currentMaxSpatialLayer = this.appData.producerData.maxSpatialLayer;
     this.parseScalabilityMode();
     this.setSpatialLayersParams();

package/src/engine/handlers/ChannelEventHandler.ts

@@ -10,7 +10,10 @@ class ChannelEventHandler {
 
   constructor(engine: Engine) {
     this.engine = engine;
-    this.logger = new Logger('ChannelEvents');
+    this.logger = new Logger({
+      logLevel: engine.logLevel,
+      namespace: 'ChannelEvents',
+    });
   }
 
   public subscribeToEvents(): void {

package/src/engine/handlers/MediaSoupEventHandler.ts

@@ -17,7 +17,10 @@ class MediaSoupEventHandler {
 
   constructor(engine: Engine) {
     this.engine = engine;
-    this.logger = new Logger('MediasoupEvents');
+    this.logger = new Logger({
+      logLevel: engine.logLevel,
+      namespace: 'MediasoupEvents',
+    });
   }
 
   public subscribeToEvents(): void {

package/src/engine/index.ts

@@ -10,6 +10,7 @@ import {
   Track,
   TrackLabel,
   LogMessageHandler,
+  LogLevel,
 } from '../types/common';
 import EnhancedEventEmitter from '../EnhancedEventEmitter';
 import System from './system';
@@ -28,13 +29,19 @@ import AudioTrack from './media/tracks/AudioTrack';
 import PeerTrack from './media/tracks/PeerTrack';
 import WebRTCIssueDetector from './wid/WebRTCIssueDetector';
 import { retryAsync } from '../helpers/retry';
-import { CreateNetworkParams, EngineDependenciesFactory } from '../types/engine';
+import { EngineDependenciesFactory, IssuesHandler } from '../types/engine';
+import { LogLevels } from '../constants/common';
+import { LoadBalancerApiClientParams } from './network/LoadBalancerClient';
 
 type EngineParams = {
   clientEventEmitter: EnhancedEventEmitter,
-  network: CreateNetworkParams,
-  onLogMessage?: LogMessageHandler;
+  network: {
+    loadbalancer: LoadBalancerApiClientParams;
+  },
   dependenciesFactory: EngineDependenciesFactory;
+  logLevel?: LogLevel;
+  onLogMessage?: LogMessageHandler;
+  onIssues?: IssuesHandler;
 };
 
 class Engine {
@@ -46,6 +53,8 @@ class Engine {
 
   public clientEventEmitter: EnhancedEventEmitter;
 
+  public logLevel: LogLevel;
+
   private readonly peersRepository: Map<string, Peer>;
 
   private channelEventsHandler: ChannelEventHandler;
@@ -71,16 +80,33 @@ class Engine {
       clientEventEmitter,
       network,
       dependenciesFactory,
+      logLevel,
     } = params;
-    this.system = dependenciesFactory.createSystem(clientEventEmitter);
-    this.media = dependenciesFactory.createMedia();
-    this.network = dependenciesFactory.createNetwork(network);
+    this.logLevel = logLevel || LogLevels.Error;
+    this.system = dependenciesFactory.createSystem({
+      logLevel: this.logLevel,
+      clientEventEmitter,
+    });
+    this.media = dependenciesFactory.createMedia({
+      logLevel: this.logLevel,
+    });
+    this.network = dependenciesFactory.createNetwork({
+      logLevel: this.logLevel,
+      loadbalancer: network.loadbalancer,
+    });
     this.peersRepository = new Map<string, Peer>();
     this.clientEventEmitter = clientEventEmitter;
     this.channelEventsHandler = dependenciesFactory.createChannelEventHandler(this);
     this.mediaSoupEventsHandler = dependenciesFactory.createMediaSoupEventHandler(this);
-    this.logger = new Logger('Engine', params.onLogMessage);
-    this.webRtcIssueDetector = dependenciesFactory.createIssueDetector({ logger: this.logger });
+    this.logger = new Logger({
+      logLevel: this.logLevel,
+      namespace: 'Engine',
+      onLogMessage: params.onLogMessage,
+    });
+
+    this.webRtcIssueDetector = dependenciesFactory.createIssueDetector({
+      onIssues: params.onIssues,
+    });
 
     this.watchSocketState();
   }
@@ -441,6 +467,10 @@ class Engine {
       minBackoffDelayMs: 150,
       maxBackoffDelayMs: 5_000,
       actionName: 'connectToSocketServer',
+      logger: new Logger({
+        namespace: 'RetrySocketConnect',
+        logLevel: this.logLevel,
+      }),
     });
   }
 
@@ -520,6 +550,10 @@ class Engine {
       maxRetries: 3,
       minBackoffDelayMs: 300,
       actionName: 'sendJoinChannelRequest',
+      logger: new Logger({
+        namespace: 'RetryJoin',
+        logLevel: this.logLevel,
+      }),
     });
   }
 

package/src/engine/media/index.ts

@@ -2,10 +2,13 @@ import { Device } from 'mediasoup-client';
 import { RtpCapabilities, RtpCodecCapability } from 'mediasoup-client/lib/RtpParameters';
 import VideoTrack from './tracks/VideoTrack';
 import AudioTrack from './tracks/AudioTrack';
-import { CreateScreenVideoTrackOptions, CreateVideoTrackParams, Track } from '../../types/common';
+import {
+  CreateScreenVideoTrackOptions, CreateVideoTrackParams, LogLevel, Track,
+} from '../../types/common';
 import Logger from '../Logger';
 import { VIDEO_CONSTRAINS } from '../../constants/videoConstrains';
 import { SCREEN_SHARING_SIMULCAST_ENCODINGS, WEBCAM_SIMULCAST_ENCODINGS } from '../../constants/simulcastEncodings';
+import { CreateMediaParams } from '../../types/engine';
 
 class Media {
   public isDeviceLoaded = false;
@@ -14,7 +17,17 @@ class Media {
 
   private tracks: Map<string, Track> = new Map();
 
-  #logger = new Logger('Media');
+  #logger: Logger;
+
+  #logLevel: LogLevel;
+
+  constructor(params: CreateMediaParams) {
+    this.#logLevel = params.logLevel;
+    this.#logger = new Logger({
+      namespace: 'Media',
+      logLevel: params.logLevel,
+    });
+  }
 
   get mediasoupDevice(): Device {
     if (!this.device) {
@@ -50,8 +63,8 @@ class Media {
     const mediaStreamTracks = stream.getTracks();
     return mediaStreamTracks.map((mediaStreamTrack) => {
       const track = mediaStreamTrack.kind === 'audio'
-        ? new AudioTrack(mediaStreamTrack)
-        : new VideoTrack(mediaStreamTrack);
+        ? new AudioTrack({ mediaStreamTrack, logLevel: this.#logLevel })
+        : new VideoTrack({ mediaStreamTrack, logLevel: this.#logLevel });
 
       this.tracks.set(track.id, track);
       this.#logger.debug('createTrack() track created', {

package/src/engine/media/tracks/BaseTrack.ts

@@ -1,8 +1,13 @@
 import { Producer } from 'mediasoup-client/lib/Producer';
 import { MediaKind } from 'mediasoup-client/lib/RtpParameters';
-import { EncoderConfig, TrackLabel } from '../../../types/common';
+import { EncoderConfig, LogLevel, TrackLabel } from '../../../types/common';
 import Logger from '../../Logger';
 
+export type BaseTrackConstructorParams = {
+  mediaStreamTrack: MediaStreamTrack,
+  logLevel: LogLevel,
+};
+
 class BaseTrack {
   readonly #mediaStreamTrack: MediaStreamTrack;
 
@@ -12,10 +17,15 @@ class BaseTrack {
 
   private label: TrackLabel = TrackLabel.Unknown;
 
-  protected logger = new Logger('Track');
+  protected logger: Logger;
 
-  constructor(mediaStreamTrack: MediaStreamTrack) {
+  constructor(params: BaseTrackConstructorParams) {
+    const { mediaStreamTrack, logLevel } = params;
     this.#mediaStreamTrack = mediaStreamTrack;
+    this.logger = new Logger({
+      namespace: 'Track',
+      logLevel,
+    });
   }
 
   get mediaStreamTrack(): MediaStreamTrack {

package/src/engine/media/tracks/PeerTrack.ts

@@ -27,7 +27,7 @@ class PeerTrack {
 
   readonly #engine: Engine;
 
-  readonly #logger = new Logger('PeerTrack');
+  readonly #logger: Logger;
 
   readonly #peerEventEmitter: EnhancedEventEmitter;
 
@@ -38,6 +38,10 @@ class PeerTrack {
     this.label = payload.label;
     this.consumer = payload.consumer;
     this.#engine = payload.engine;
+    this.#logger = new Logger({
+      logLevel: payload.engine.logLevel,
+      namespace: 'PeerTrack',
+    });
     this.#peerEventEmitter = payload.peerEventEmitter;
     this.#paused = payload.isPaused;
     this.#peerEventEmitter.safeEmit(PEER_EVENTS.trackStart, this);

package/src/engine/network/Socket.ts

@@ -1,9 +1,13 @@
 import { io, Socket } from 'socket.io-client';
 import EnhancedEventEmitter from '../../EnhancedEventEmitter';
 import { SocketIOEvents } from '../../constants/events';
-import { SocketResponse } from '../../types/common';
+import { LogLevel, SocketResponse } from '../../types/common';
 import Logger from '../Logger';
 
+export type SocketIOConstructorParams = {
+  logLevel: LogLevel,
+};
+
 class SocketIO {
   public connection?: Socket;
 
@@ -29,8 +33,11 @@ class SocketIO {
     'transport error': 'transport.error',
   };
 
-  constructor() {
-    this.logger = new Logger('Socket');
+  constructor(params: SocketIOConstructorParams) {
+    this.logger = new Logger({
+      namespace: 'Socket',
+      logLevel: params.logLevel,
+    });
   }
 
   get observer(): EnhancedEventEmitter {

package/src/engine/network/index.ts

@@ -6,13 +6,14 @@ import {
 } from 'mediasoup-client/lib/Transport';
 import { Device } from 'mediasoup-client';
 import SocketIO from './Socket';
-import { ProduceParams } from '../../types/common';
+import { LogLevel, ProduceParams } from '../../types/common';
 import LoadBalancerApiClient from './LoadBalancerClient';
 import { MEDIASOUP_EVENTS, MEDIASOUP_TRANSPORT_EVENTS } from '../../constants/events';
 import Logger from '../Logger';
 
 export type NetworkParams = {
   socketClient: SocketIO;
+  logLevel: LogLevel,
   loadBalancerApiClient: LoadBalancerApiClient;
 };
 
@@ -31,7 +32,10 @@ class Network {
     const { socketClient, loadBalancerApiClient } = params;
     this.socket = socketClient;
     this.loadBalancerClient = loadBalancerApiClient;
-    this.logger = new Logger('Network');
+    this.logger = new Logger({
+      namespace: 'Network',
+      logLevel: params.logLevel,
+    });
   }
 
   async closeRemoteProducer(producerId: string): Promise<void> {

package/src/engine/system/index.ts

@@ -1,12 +1,9 @@
+import { CreateSystemParams } from '../../types/engine';
 import { CLIENT_EVENTS } from '../../constants/events';
 import EnhancedEventEmitter from '../../EnhancedEventEmitter';
 import { AvailableMediaDevices } from '../../types/common';
 import Logger from '../Logger';
 
-type SystemParams = {
-  clientEventEmitter: EnhancedEventEmitter,
-};
-
 class System {
   public isEnableVideoDevicesLock = false;
 
@@ -24,10 +21,13 @@ class System {
 
   private readonly logger: Logger;
 
-  constructor(params: SystemParams) {
-    const { clientEventEmitter } = params;
+  constructor(params: CreateSystemParams) {
+    const { clientEventEmitter, logLevel } = params;
     this.clientEventEmitter = clientEventEmitter;
-    this.logger = new Logger('System');
+    this.logger = new Logger({
+      namespace: 'System',
+      logLevel,
+    });
     this.listenDevices();
   }
 

package/src/engine/wid/WebRTCIssueDetector.ts

@@ -28,8 +28,8 @@ class WebRTCIssueDetector {
   #running = false;
 
   constructor(params: WebRTCIssueDetectorConstructorParams) {
-    if (params.onIssue) {
-      this.eventEmitter.on(EventType.Issue, params.onIssue);
+    if (params.onIssues) {
+      this.eventEmitter.on(EventType.Issue, params.onIssues);
     }
 
     // Move instantiation from the constructor

package/src/engine/wid/types.ts

@@ -19,7 +19,7 @@ export enum EventType {
 export type EventPayload = IssueDetectorResult;
 
 export type WebRTCIssueDetectorConstructorParams = {
-  onIssue?: (payload: IssueDetectorResult) => void,
+  onIssues?: (payload: IssueDetectorResult) => void,
 };
 
 export enum IssueType {

package/src/helpers/retry.ts

@@ -6,9 +6,9 @@ export type RetryOpts = {
   minBackoffDelayMs?: number;
   maxBackoffDelayMs?: number;
   actionName?: string; // human-readable action name for debug purposes
+  logger?: Logger;
 };
 
-const logger = new Logger('Retry');
 const timeProvider = new DefaultTimeProvider();
 
 const retryAsync = async <ReturnType>(
@@ -28,7 +28,9 @@ const retryAsync = async <ReturnType>(
       return await action();
     } catch (err: unknown) {
       lastError = err;
-      logger.warn('Action retry failed', currentAttempt, opts.actionName, err);
+      if (opts.logger) {
+        opts.logger.info('Action retry failed', currentAttempt, opts.actionName, err);
+      }
 
       if (currentAttempt < maxRetries) {
         const delay = 2 ** (currentAttempt - 1) * minBackoffDelayMs;