@livedigital/client 2.12.0 → 2.14.1

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;

package/src/index.ts

@@ -4,6 +4,7 @@ import {
   CreateMicrophoneAudioTrackOptions,
   CreateScreenMediaOptions,
   JoinChannelParams,
+  LogLevel,
   LogMessageHandler,
   Role,
   Track,
@@ -13,13 +14,16 @@ import Engine from './engine';
 import Peer from './engine/Peer';
 import { LoadBalancerApiClientParams } from './engine/network/LoadBalancerClient';
 import DefaultEngineDependenciesFactory from './engine/DefaultEngineDependenciesFactory';
+import { IssuesHandler } from './types/engine';
 
 type ClientParams = {
   observer?: EnhancedEventEmitter;
   network?: {
     loadbalancer?: LoadBalancerApiClientParams;
   },
+  logLevel: LogLevel,
   onLogMessage?: LogMessageHandler;
+  onIssues?: IssuesHandler,
 };
 
 class Client {
@@ -28,7 +32,14 @@ class Client {
   private readonly _observer: EnhancedEventEmitter;
 
   constructor(params: ClientParams) {
-    const { observer, network, onLogMessage } = params;
+    const {
+      observer,
+      network,
+      onLogMessage,
+      onIssues,
+      logLevel,
+    } = params;
+
     this._observer = observer ?? new EnhancedEventEmitter();
     const dependenciesFactory = new DefaultEngineDependenciesFactory();
     this.engine = new Engine({
@@ -40,7 +51,9 @@ class Client {
           customNode: network?.loadbalancer?.customNode,
         },
       },
+      logLevel,
       onLogMessage,
+      onIssues,
     });
   }
 

package/src/types/common.ts

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

package/src/types/engine.ts

@@ -7,20 +7,33 @@ 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 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;