@livedigital/client 3.34.0-createCustomMediaTracks.1 → 3.34.0

package/dist/inversify.tokens.d.ts

@@ -30,5 +30,8 @@ export declare enum TOKEN {
     IntegrationsService = "IntegrationsService",
     ProcessorsCache = "ProcessorsCache",
     StatsHandler = "StatsHandler",
-    DataChannelsManager = "DataChannelsManager"
+    DataChannelsManager = "DataChannelsManager",
+    WIDHandler = "WIDHandler",
+    AnalyticsApiClient = "AnalyticsApiClient",
+    TransportsStatsProvider = "TransportsStatsProvider"
 }

package/dist/types/common.d.ts

@@ -62,11 +62,16 @@ export declare type AvailableMediaDevices = {
     video: MediaDeviceInfo[];
     audio: MediaDeviceInfo[];
 };
+export declare enum DatacenterType {
+    P2P = "p2p",
+    Common = "common"
+}
 export declare type JoinChannelParams = {
     channelId: string;
     token: string;
     role: Role;
     appData?: Record<string, unknown>;
+    isP2pCall?: boolean;
 };
 export declare type ChannelEvent = {
     eventName: string;
@@ -119,11 +124,6 @@ export declare type CreateScreenMediaOptions = BaseVideoTrackOptions & BaseAudio
     videoEncoderConfig?: VideoEncoderConfig;
     audioEncoderConfig?: AudioEncoderConfig;
 };
-export declare type CreateCustomMediaOptions = BaseVideoTrackOptions & BaseAudioTrackOptions & {
-    videoEncoderConfig?: VideoEncoderConfig;
-    audioEncoderConfig?: AudioEncoderConfig;
-    mediaStream: MediaStream;
-};
 export declare enum TrackLabel {
     Camera = "camera",
     CameraPreview = "camera-preview",
@@ -152,10 +152,6 @@ export declare type ChangePreferredLayersPayload = PreferredLayersParams & {
     spatialLayer: number;
     temporalLayer: number;
 };
-export declare type ConsumerScorePayload = {
-    consumerId: string;
-    score: number;
-};
 export declare type CreateVideoTrackParams = {
     videoTrackOptions: boolean | MediaTrackConstraints;
     encoderConfig: VideoEncoderConfig;
@@ -244,7 +240,6 @@ export declare type TrackInboundStats = {
     currentSpatialLayerParams?: SpatialLayerParams;
     availableSpatialLayers?: SpatialLayerParams[];
     requestedSpatialLayer?: number;
-    score: number;
     dtlsState?: RTCDtlsTransportState;
     rtcStats?: ExtendedRTCInboundRtpStreamStats;
 };

package/dist/types/engine.d.ts

@@ -6,7 +6,7 @@ import { ActivityConfirmationRequiredPayload, AvailableMediaDevices, ChannelEven
 import { BaseTrack, InitEffectsSDKParams, Track } from './media';
 export declare type IssuesHandler = (issues: IssueDetectorResult) => void;
 export declare type StatsHandler = (stats: StatsReportItem[]) => void;
-export declare type NetworkScoresUpdatedHandler = (networks: NetworkScores) => void;
+export declare type NetworkScoresUpdatedHandler = (networkScores: NetworkScores) => void;
 export interface CreateIssueDetectorParams {
     disableWid: boolean;
     onIssues?: IssuesHandler;
@@ -25,11 +25,7 @@ export interface ConnectParams {
     channelId: string;
     role: Role;
     token: string;
-}
-export interface NodeActiveStreamsStat {
-    node?: string;
-    inboundActiveStreams: number;
-    outboundActiveStreams: number;
+    isP2pCall?: boolean;
 }
 export interface ChannelStateInconsistentPayload {
     type: InconsistenceType;

package/dist/types/network.d.ts

@@ -1,9 +1,10 @@
-import { Role } from './common';
+import { DatacenterType, Role } from './common';
 import { SocketIOEvents } from './socket';
 import { NETWORK_OBSERVER_EVENTS } from '../constants/events';
 export declare type GetNodeRequest = {
     channelId: string;
     role: Role;
+    datacenterType?: DatacenterType;
 };
 export declare type GetNodeResponse = {
     webSocketUrl: string;

package/package.json

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

package/src/constants/events.ts

@@ -86,7 +86,6 @@ export const MEDIASOUP_EVENTS = {
   closeConsumer: 'consumer.close',
   pauseConsumer: 'consumer.pause',
   resumeConsumer: 'consumer.resume',
-  consumerScore: 'consumer.score',
   consumerChangePreferredLayers: 'consumer.changeConsumerPreferredLayers',
   consumerRequestKeyFrame: 'consumer.requestKeyFrame',
   transportCreate: 'transport.create',

package/src/engine/Peer.ts

@@ -5,7 +5,7 @@ import EnhancedEventEmitter from '../EnhancedEventEmitter';
 import validateAppData from '../helpers/appDataValidator';
 import { logResponse } from '../helpers/peer';
 import {
-  ChangePreferredLayersPayload, ConsumerScorePayload, PayloadOfPublishedMedia,
+  ChangePreferredLayersPayload, PayloadOfPublishedMedia,
   PayloadOfUnpublishedMedia, PeerGroup, PeerInfo, PeerShortData, ProducerData,
   ProducerSetMaxSpatialLayer, Role, SubscribeOptions, TrackLabel, TrackLabelString,
 } from '../types/common';
@@ -70,7 +70,6 @@ export type PeerObserverEvents = {
   [MEDIASOUP_EVENTS.closeConsumer]: [consumerId: string];
   [MEDIASOUP_EVENTS.pauseConsumer]: [consumerId: string];
   [MEDIASOUP_EVENTS.resumeConsumer]: [consumerId: string];
-  [MEDIASOUP_EVENTS.consumerScore]: [ConsumerScorePayload];
   [MEDIASOUP_EVENTS.consumerChangePreferredLayers]: [ChangePreferredLayersPayload];
   [MEDIASOUP_EVENTS.producerSetMaxSpatialLayer]: [ProducerSetMaxSpatialLayer];
   [CHANNEL_EVENTS.updatePeerAppData]: [Record<string, unknown>];
@@ -434,13 +433,6 @@ class Peer {
       }
     });
 
-    this.observer.on(MEDIASOUP_EVENTS.consumerScore, (payload: ConsumerScorePayload) => {
-      const consumer = this.getConsumerById(payload.consumerId);
-      if (consumer) {
-        consumer.score = payload.score;
-      }
-    });
-
     this.observer.on(MEDIASOUP_EVENTS.producerSetMaxSpatialLayer, async (payload: ProducerSetMaxSpatialLayer) => {
       const { producerId, spatialLayer } = payload;
       const consumer = this.getConsumerByProducerId(producerId);
@@ -505,7 +497,6 @@ class Peer {
       MEDIASOUP_EVENTS.closeConsumer,
       MEDIASOUP_EVENTS.pauseConsumer,
       MEDIASOUP_EVENTS.resumeConsumer,
-      MEDIASOUP_EVENTS.consumerScore,
       MEDIASOUP_EVENTS.consumerChangePreferredLayers,
       MEDIASOUP_EVENTS.producerSetMaxSpatialLayer,
       CHANNEL_EVENTS.updatePeerAppData,

package/src/engine/PeerConsumer.ts

@@ -18,8 +18,6 @@ export interface PeerConsumerConstructorParams extends PeerConsumerDependencies
 }
 
 class PeerConsumer {
-  public score = 10;
-
   public spatialLayers = 0;
 
   public temporalLayers = 0;
@@ -191,7 +189,6 @@ class PeerConsumer {
       return {
         consumerId: this.consumer.id,
         codec: this.consumer.rtpParameters.codecs.find((codec) => filterStatsCodecs(codec)),
-        score: this.score,
         dtlsState: this.consumer.rtpReceiver?.transport?.state,
         availableSpatialLayers: this.availableSpatialLayers,
         currentSpatialLayerParams: this.currentSpatialLayerParams,

package/src/engine/PeerProducer.ts

@@ -19,8 +19,6 @@ class PeerProducer {
 
   readonly maxSpatialLayer: number;
 
-  public score = 10;
-
   constructor(params: ProducerData) {
     const {
       id, kind, peerId, label, paused,

package/src/engine/WIDHandler.ts

@@ -0,0 +1,142 @@
+import { MessageBatcher } from 'message-batcher';
+import { IssueDetectorResult, NetworkScores } from 'webrtc-issue-detector';
+import { inject, injectable } from 'inversify';
+import { NetworkMetric } from './analyticsApiClient/types';
+import clientMetaProvider from '../ClientMetaProvider';
+import { TOKEN } from '../inversify.tokens';
+import { getClientUniqueId } from './analyticsApiClient/helper';
+import AnalyticsApiClient from './analyticsApiClient';
+import type { IPeersService } from './Peers';
+import SocketIO from './network/Socket';
+import { MyPeer } from './MyPeer';
+import type { LoggerFactory } from '../types/container';
+import Logger from './Logger';
+import TransportsStatsProvider from './WebRTCStats/TransportsStatsProvider';
+
+const WIDSupportedIssueReasons = [
+  'frozen-video-track',
+  'network-media-sync-failure',
+  'encoder-cpu-throttling',
+  'decoder-cpu-throttling',
+  'missing-video-stream-data',
+  'missing-audio-stream-data',
+];
+
+interface NodeActiveStreamsStat {
+  node?: string;
+  inboundActiveStreams: number;
+  outboundActiveStreams: number;
+}
+
+@injectable()
+class WIDHandler {
+  readonly #networkScoresBatcher: MessageBatcher;
+
+  readonly #webrtcIssuesBatcher: MessageBatcher;
+
+  readonly #logger: Logger;
+
+  constructor(
+    @inject(TOKEN.AnalyticsApiClient) private readonly analyticsApiClient: AnalyticsApiClient,
+    @inject(TOKEN.Peers) private readonly peers: IPeersService,
+    @inject(TOKEN.SocketIO) private readonly socket: SocketIO,
+    @inject(TOKEN.MyPeer) private readonly myPeer: MyPeer,
+    @inject(TOKEN.LoggerFactory) loggerFactory: LoggerFactory,
+    @inject(TOKEN.TransportsStatsProvider) private readonly transportsStatsProvider: TransportsStatsProvider,
+  ) {
+    this.#logger = loggerFactory('IntegrationsService');
+    this.#webrtcIssuesBatcher = new MessageBatcher({ MaxBatchSize: 50, MaxDelay: 60000, MinDelay: 30000 });
+    this.#webrtcIssuesBatcher
+      .on('batch', (reasons: string[]) => {
+        this.analyticsApiClient.metrics.sendWIDMetrics({
+          reasons,
+          clientMeta: this.getClientMeta(),
+        });
+      });
+
+    this.#networkScoresBatcher = new MessageBatcher({ MaxBatchSize: 100, MaxDelay: 60000, MinDelay: 30000 });
+    this.#networkScoresBatcher
+      .on('batch', (metrics: NetworkMetric[]) => {
+        this.analyticsApiClient.metrics.sendNetworkMetrics({
+          metrics,
+          clientMeta: this.getClientMeta(),
+        });
+      });
+  }
+
+  handleIssues(issues: IssueDetectorResult) {
+    issues.map((issue) => this.#logger.info('WebRTCIssue', issue));
+
+    const supportedIssues = issues
+      .filter((issue) => WIDSupportedIssueReasons.includes(issue.reason));
+
+    if (supportedIssues.length === 0) {
+      return;
+    }
+
+    supportedIssues
+      .map((issue) => this.#webrtcIssuesBatcher.Queue(issue.reason));
+  }
+
+  handleNetworkScores(networkScores: NetworkScores) {
+    const {
+      inbound,
+      outbound,
+      statsSamples: { inboundStatsSample, outboundStatsSample },
+    } = networkScores;
+    const nodeActiveStreamsStat = this.getNodeActiveStreamsStat();
+    const node = (nodeActiveStreamsStat.node)?.replace(/https:\/\/app-\d+-/, '');
+    const transportsStats = this.transportsStatsProvider.getStats();
+
+    if (inbound !== undefined && inboundStatsSample) {
+      this.#networkScoresBatcher.Queue({
+        jitter: Math.round(inboundStatsSample.avgJitter * 1000),
+        packetLoss: inboundStatsSample.packetsLoss,
+        rtt: inboundStatsSample.rtt,
+        mos: Math.round(inbound * 10) / 10,
+        streams: nodeActiveStreamsStat.inboundActiveStreams,
+        direction: 'inbound',
+        node,
+        bitrate: transportsStats?.inbound?.bitrate ?? 0,
+        timestamp: (new Date()).toISOString(),
+      } as NetworkMetric);
+    }
+
+    if (outbound !== undefined && outboundStatsSample) {
+      this.#networkScoresBatcher.Queue({
+        jitter: Math.round(outboundStatsSample.avgJitter * 1000),
+        packetLoss: outboundStatsSample.packetsLoss,
+        rtt: outboundStatsSample.rtt,
+        mos: Math.round(outbound * 10) / 10,
+        streams: nodeActiveStreamsStat.outboundActiveStreams,
+        direction: 'outbound',
+        node,
+        bitrate: transportsStats?.outbound?.bitrate ?? 0,
+        timestamp: (new Date()).toISOString(),
+      } as NetworkMetric);
+    }
+  }
+
+  private getNodeActiveStreamsStat(): NodeActiveStreamsStat {
+    const node = this.socket.getServerUrl();
+    const inboundActiveStreams = this.peers.hosts()
+      .filter((peer) => peer.id !== this.myPeer?.id)
+      .reduce((total, peer) => total + peer.getActiveTracksCount(), 0);
+    const myPeer = this.myPeer.get();
+    const outboundActiveStreams = myPeer?.getActivePublishersCount() || 0;
+    return {
+      node,
+      inboundActiveStreams,
+      outboundActiveStreams,
+    };
+  }
+
+  private getClientMeta() {
+    return {
+      ...clientMetaProvider.meta,
+      clientUniqueId: getClientUniqueId(),
+    };
+  }
+}
+
+export default WIDHandler;

package/src/engine/WebRTCStats/TransportsStatsProvider.ts

@@ -1,18 +1,33 @@
+import { inject, injectable } from 'inversify';
 import ConnectionStatManager from './ConnectionStatsManager';
 import Media from '../media';
 import { IPeersService } from '../Peers';
 import { TransportsStatsProviderParams, TransportsWebRTCStats } from './types';
+import { TOKEN } from '../../inversify.tokens';
+import type { LoggerFactory } from '../../types/container';
+import Logger from '../Logger';
 
+@injectable()
 export default class TransportsStatsProvider {
-  #sendTransportConnectionManager: ConnectionStatManager;
+  #initialized = false;
 
-  #receiveTransportConnectionManager: ConnectionStatManager;
+  #logger: Logger;
 
-  #media: Media;
+  #sendTransportConnectionManager?: ConnectionStatManager;
 
-  #peers: IPeersService;
+  #receiveTransportConnectionManager?: ConnectionStatManager;
 
-  constructor({
+  #media?: Media;
+
+  #peers?: IPeersService;
+
+  constructor(
+  @inject(TOKEN.LoggerFactory) loggerFactory: LoggerFactory,
+  ) {
+    this.#logger = loggerFactory('IntegrationsService');
+  }
+
+  init({
     sendTransportConnectionManager,
     receiveTransportConnectionManager,
     media,
@@ -22,17 +37,38 @@ export default class TransportsStatsProvider {
     this.#receiveTransportConnectionManager = receiveTransportConnectionManager;
     this.#media = media;
     this.#peers = peers;
+    this.#initialized = true;
   }
 
   getStats(): TransportsWebRTCStats {
+    try {
+      return this.doGetStats();
+    } catch (error) {
+      this.#logger.error('Failed to get stats', error);
+      return {};
+    }
+  }
+
+  clear() {
+    this.#sendTransportConnectionManager = undefined;
+    this.#receiveTransportConnectionManager = undefined;
+    this.#media = undefined;
+    this.#peers = undefined;
+  }
+
+  private doGetStats() {
+    if (!this.#initialized) {
+      throw new Error('TransportsStatsProvider is not initialized');
+    }
+
     return {
-      ...(this.#sendTransportConnectionManager.connectionStats?.id ? {
+      ...(this.#sendTransportConnectionManager?.connectionStats?.id ? {
         outbound: {
           ...this.#sendTransportConnectionManager.connectionStats,
           bitrate: this.calculateOutboundTracksBitrate(),
         },
       } : {}),
-      ...(this.#receiveTransportConnectionManager.connectionStats?.id ? {
+      ...(this.#receiveTransportConnectionManager?.connectionStats?.id ? {
         inbound: {
           ...this.#receiveTransportConnectionManager.connectionStats,
           bitrate: this.calculateInboundTracksBitrate(),
@@ -42,6 +78,10 @@ export default class TransportsStatsProvider {
   }
 
   private calculateInboundTracksBitrate(): number {
+    if (this.#peers === undefined) {
+      throw new Error('Peers is undefined');
+    }
+
     return this.#peers.hosts().reduce((sumPeersBitrate, peer) => {
       if (peer.isMe) {
         return sumPeersBitrate;
@@ -59,6 +99,10 @@ export default class TransportsStatsProvider {
   }
 
   private calculateOutboundTracksBitrate(): number {
+    if (this.#media === undefined) {
+      throw new Error('Media is undefined');
+    }
+
     return this.#media.getAllTracks().reduce((sumTracksBitrate, track) => {
       if (!track.isPublished) {
         return sumTracksBitrate;

package/src/engine/analyticsApiClient/MetricsApi.ts

@@ -0,0 +1,30 @@
+import { AxiosInstance } from 'axios';
+import axiosRetry from 'axios-retry';
+import { NetworkMetricsBatch, WIDMetricsBatch } from './types';
+
+const RETRY_COUNT = 2;
+const RETRY_DELAY_IN_MS = 1500;
+
+export default class MetricsApi {
+  private readonly api: AxiosInstance;
+
+  constructor(api: AxiosInstance) {
+    this.api = api;
+    axiosRetry(this.api, {
+      retries: RETRY_COUNT,
+      shouldResetTimeout: true,
+      retryDelay: (retryCount) => retryCount * RETRY_DELAY_IN_MS,
+      retryCondition: (error) => /^\/?log\//.test(error.config?.url ?? '') || false,
+    });
+  }
+
+  async sendNetworkMetrics(metrics: NetworkMetricsBatch): Promise<void> {
+    return this.api.post('/analytics/network-metrics', metrics);
+  }
+
+  async sendWIDMetrics(metrics: WIDMetricsBatch): Promise<void> {
+    return this.api.post('/analytics/wid-metrics', {
+      ...metrics,
+    });
+  }
+}

package/src/engine/analyticsApiClient/index.ts

@@ -1,13 +1,18 @@
 import axios, { AxiosInstance } from 'axios';
 import qs from 'qs';
+import { injectable } from 'inversify';
 import { receiveClientTrackingId } from './helper';
 import LogApi from './LogApi';
+import MetricsApi from './MetricsApi';
 
+@injectable()
 export default class AnalyticsApiClient {
   private readonly api: AxiosInstance;
 
   private readonly logApi: LogApi;
 
+  private readonly metricsApi: MetricsApi;
+
   constructor() {
     this.api = axios.create({
       baseURL: process.env.LIVEDIGITAL_APP_ANALYTICS_API_BASE_URL,
@@ -24,9 +29,14 @@ export default class AnalyticsApiClient {
     this.api.defaults.headers.common.Expires = '0';
 
     this.logApi = new LogApi(this.api);
+    this.metricsApi = new MetricsApi(this.api);
   }
 
   get log(): LogApi {
     return this.logApi;
   }
+
+  get metrics(): MetricsApi {
+    return this.metricsApi;
+  }
 }

package/src/engine/analyticsApiClient/types.ts

@@ -1,3 +1,4 @@
+import { ClientMetaPayload } from '../../ClientMetaProvider';
 import { LogToRemotePayload } from '../Logger';
 
 export interface BatchLogPayload {
@@ -14,12 +15,19 @@ export interface NetworkMetric {
   node: string;
   direction: 'inbound' | 'outbound';
   timestamp: string;
+  bitrate: number;
 }
 
-export interface SendNetworkMetricsPayload {
+export interface NetworkMetricsBatch {
   metrics: NetworkMetric[];
-  clientMeta: {
-    roomId: string;
-    clientUniqueId: string;
+  clientMeta: ClientMetaPayload & {
+    clientUniqueId: string
+  };
+}
+
+export interface WIDMetricsBatch {
+  reasons: string[],
+  clientMeta: ClientMetaPayload & {
+    clientUniqueId: string
   };
 }

package/src/engine/handlers/MediaSoupEventHandler.ts

@@ -206,28 +206,6 @@ class MediaSoupEventHandler {
     });
   }
 
-  handleConsumerScoreEvent(payload: string): void {
-    try {
-      const { peerId, consumerId, score } = JSON.parse(payload) as {
-        peerId: string;
-        consumerId: string;
-        score: number;
-      };
-
-      const peer = this.peers.get(peerId);
-      if (!peer) {
-        return;
-      }
-
-      peer.observer.safeEmit(MEDIASOUP_EVENTS.consumerScore, { consumerId, score });
-    } catch (error: unknown) {
-      this.#logger.error('Failed to handle consumer score event', {
-        error,
-        payload,
-      });
-    }
-  }
-
   private removeEventListeners() {
     if (!this.eventsQueue) {
       return;