@livedigital/client 2.22.1 → 2.23.0-get-stats.1

package/dist/types/common.d.ts

@@ -236,6 +236,60 @@ export declare enum DeviceErrors {
     DeviceIsBusy = "DeviceIsBusy",
     NotAllowedError = "NotAllowedError"
 }
+export declare type TrackInboundStats = {
+    consumerId: string;
+    codec?: RTCRtpCodecParameters;
+    currentSpatialLayerParams?: SpatialLayerParams;
+    availableSpatialLayers?: SpatialLayerParams[];
+    requestedSpatialLayer?: number;
+    score: number;
+    dtlsState?: RTCDtlsTransportState;
+    rtcStats?: ExtendedRTCInboundRtpStreamStats;
+};
+export declare type TrackOutboundStats = {
+    producerId?: string;
+    codec?: RTCRtpCodecParameters;
+    dtlsState?: RTCDtlsTransportState;
+    rtcStats?: RTCOutboundRtpStreamStats;
+};
+export declare type PeerTrackInfo = {
+    trackId: string;
+    readyState: MediaStreamTrackState;
+    isRemote: boolean;
+    kind: MediaKind;
+    label: TrackLabel;
+    paused: boolean;
+    width?: number;
+    height?: number;
+    frameRate?: number;
+    aspectRatio?: number;
+    trackInboundStats?: TrackInboundStats;
+    trackOutboundStats?: TrackOutboundStats;
+};
+export declare type BaseTrackInfo = {
+    trackId: string;
+    readyState: MediaStreamTrackState;
+    kind: MediaKind;
+    label: TrackLabel;
+    paused: boolean;
+    width?: number;
+    height?: number;
+    frameRate?: number;
+    aspectRatio?: number;
+    trackOutboundStats?: TrackOutboundStats;
+};
+export declare type PeerInfo = {
+    id: string;
+    appData: Record<string, unknown>;
+    role: Role;
+    isBroadcaster: boolean;
+    channelIds: string[];
+    appId: string;
+    uid?: string;
+    loginDate: Date;
+    connectionQuality: number;
+    tracks: PeerTrackInfo[];
+};
 export declare type UpdatePeerAppDataPayload = {
     peerId: string;
     appData: Record<string, unknown>;

package/package.json

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

package/src/engine/Peer.ts

@@ -8,6 +8,7 @@ import {
   ChangePreferredLayersPayload,
   Role,
   ProducerSetMaxSpatialLayer,
+  PeerInfo,
 } from '../types/common';
 import EnhancedEventEmitter from '../EnhancedEventEmitter';
 import Engine from './index';
@@ -109,6 +110,10 @@ class Peer {
     return this.id === this.engine.mySocketId;
   }
 
+  get isBroadcaster(): boolean {
+    return this.channelIds.length > 1;
+  }
+
   public get publishedMedia(): PayloadOfPublishedMedia[] {
     return Array.from(this.producers.values()).map((producer) => ({
       producerId: producer.id,
@@ -157,6 +162,26 @@ class Peer {
     }
   }
 
+  async getInfo(): Promise<PeerInfo> {
+    try {
+      return {
+        id: this.id,
+        appData: this.appData,
+        role: this.role,
+        isBroadcaster: this.isBroadcaster,
+        channelIds: this.channelIds,
+        appId: this.appId,
+        uid: this.uid,
+        loginDate: this.loginDate,
+        connectionQuality: this.overallConnectionQuality,
+        tracks: await Promise.all(Array.from(this.tracks.values()).map((track) => track.getInfo())),
+      };
+    } catch (error) {
+      this.logger.error('getInfo()', { peer: this, error });
+      throw new Error('Error get info');
+    }
+  }
+
   private handleNewProducer(producerData: ProducerData): void {
     if (this.producers.get(producerData.id)) {
       return;

package/src/engine/PeerConsumer.ts

@@ -6,6 +6,7 @@ import {
   ExtendedRTCInboundRtpStreamStats,
   LogLevel,
   SpatialLayerParams,
+  TrackInboundStats,
 } from '../types/common';
 import Logger from './Logger';
 
@@ -167,6 +168,24 @@ class PeerConsumer {
     this.currentMaxSpatialLayer = spatialLayer;
   }
 
+  async getStats(): Promise<TrackInboundStats | undefined> {
+    try {
+      return {
+        consumerId: this.consumer.id,
+        codec: this.consumer.rtpParameters.codecs.find((codec) => codec.mimeType !== 'rtx'),
+        score: this.score,
+        dtlsState: this.consumer.rtpReceiver?.transport?.state,
+        availableSpatialLayers: this.availableSpatialLayers,
+        currentSpatialLayerParams: this.currentSpatialLayerParams,
+        requestedSpatialLayer: this.requestedSpatialLayer,
+        rtcStats: await this.getInboundRTPStreamStats(),
+      };
+    } catch (error) {
+      this.logger.debug('getStats()', { error });
+      return undefined;
+    }
+  }
+
   async getInboundRTPStreamStats(): Promise<ExtendedRTCInboundRtpStreamStats> {
     return new Promise((resolve, reject) => {
       const getRTCStatsReport = async (attempt = 0) => {

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

@@ -1,10 +1,11 @@
 import { Producer } from 'mediasoup-client/lib/Producer';
 import { MediaKind } from 'mediasoup-client/lib/RtpParameters';
 import {
+  BaseTrackInfo,
   EncoderConfig,
   LogLevel,
   SocketResponse,
-  TrackLabel,
+  TrackLabel, TrackOutboundStats,
   TrackProduceParams,
 } from '../../../types/common';
 import Logger from '../../Logger';
@@ -41,7 +42,7 @@ class BaseTrack {
 
   #producerRestarted = false;
 
-  #clientEventEmitter: EnhancedEventEmitter;
+  readonly #clientEventEmitter: EnhancedEventEmitter;
 
   #closed = false;
 
@@ -379,6 +380,69 @@ class BaseTrack {
       throw new Error('Can`t resume track');
     }
   }
+
+  async getInfo(): Promise<BaseTrackInfo> {
+    const {
+      width, height, frameRate, aspectRatio,
+    } = this.#mediaStreamTrack.getSettings();
+    return {
+      trackId: this.#mediaStreamTrack.id,
+      readyState: this.#mediaStreamTrack.readyState,
+      kind: this.kind,
+      label: this.label,
+      width,
+      height,
+      frameRate,
+      aspectRatio,
+      paused: this.isPaused,
+      trackOutboundStats: await this.getStats(),
+    };
+  }
+
+  async getStats(): Promise<TrackOutboundStats | undefined> {
+    try {
+      return {
+        producerId: this.producer?.id,
+        codec: this.producer?.rtpParameters.codecs.find((codec) => codec.mimeType !== 'rtx'),
+        dtlsState: this.producer?.rtpSender?.transport?.state,
+        rtcStats: await this.getOutboundRTPStreamStats(),
+      };
+    } catch (error) {
+      this.logger.debug('getStats()', { error });
+      return undefined;
+    }
+  }
+
+  private getOutboundRTPStreamStats(): Promise<RTCOutboundRtpStreamStats> {
+    return new Promise((resolve, reject) => {
+      const getRTCStatsReport = async (attempt = 0) => {
+        if (!this.producer) {
+          throw new Error('Producer is missed');
+        }
+
+        try {
+          const rtcStatsReport = await this.producer.getStats();
+          const outboundRTPStreamStats: RTCOutboundRtpStreamStats = Array.from(rtcStatsReport.values())
+            .find((stat) => stat.type === 'outbound-rtp');
+          if (!outboundRTPStreamStats && attempt < 5) {
+            setTimeout(() => getRTCStatsReport(attempt + 1), 150);
+            return;
+          }
+
+          if (attempt >= 5 && !outboundRTPStreamStats) {
+            reject(new Error('OutboundRTPStreamStat not exist'));
+          }
+
+          resolve(outboundRTPStreamStats);
+        } catch (error) {
+          reject(new Error('Can not get RTCStatsReport'));
+          this.logger.debug('getOutboundRTPStreamStats()', { error });
+        }
+      };
+
+      getRTCStatsReport();
+    });
+  }
 }
 
 export default BaseTrack;

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

@@ -3,7 +3,8 @@ import {
   PreferredLayersParams,
   SetConsumerPriorityParams,
   SpatialLayerParams,
-  TrackLabel,
+  PeerTrackInfo,
+  TrackLabel, TrackOutboundStats,
 } from '../../../types/common';
 import Logger from '../../Logger';
 import { MEDIASOUP_EVENTS, PEER_EVENTS } from '../../../constants/events';
@@ -57,6 +58,10 @@ class PeerTrack {
     this.#peerEventEmitter.safeEmit(PEER_EVENTS.trackStart, this);
   }
 
+  get isRemote(): boolean {
+    return !!this.consumer;
+  }
+
   get mediaStreamTrack(): MediaStreamTrack {
     return this.#mediaStreamTrack;
   }
@@ -238,6 +243,39 @@ class PeerTrack {
     return this.consumer.availableSpatialLayers;
   }
 
+  async getInfo(): Promise<PeerTrackInfo> {
+    const {
+      width, height, frameRate, aspectRatio,
+    } = this.#mediaStreamTrack.getSettings();
+    return {
+      trackId: this.#mediaStreamTrack.id,
+      readyState: this.#mediaStreamTrack.readyState,
+      isRemote: this.isRemote,
+      kind: this.kind,
+      label: this.label,
+      width,
+      height,
+      frameRate,
+      aspectRatio,
+      paused: this.#paused,
+      trackInboundStats: await this.consumer?.getStats(),
+      trackOutboundStats: await this.getOutboundStats(),
+    };
+  }
+
+  private async getOutboundStats(): Promise<TrackOutboundStats | undefined> {
+    if (this.isRemote) {
+      return undefined;
+    }
+
+    const outboundTrack = this.#engine.media.getAllTracks().find((track) => track.getLabel() === this.label);
+    if (!outboundTrack) {
+      return undefined;
+    }
+
+    return outboundTrack.getStats();
+  }
+
   private async requestMaxSpatialLayer(consumerId: string, spatialLayer: number): Promise<void> {
     try {
       if (!this.consumer) {

package/src/types/common.ts

@@ -274,6 +274,65 @@ export enum DeviceErrors {
   NotAllowedError = 'NotAllowedError',
 }
 
+export type TrackInboundStats = {
+  consumerId: string,
+  codec?: RTCRtpCodecParameters,
+  currentSpatialLayerParams?: SpatialLayerParams,
+  availableSpatialLayers?: SpatialLayerParams[],
+  requestedSpatialLayer?: number,
+  score: number,
+  dtlsState?: RTCDtlsTransportState,
+  rtcStats?: ExtendedRTCInboundRtpStreamStats,
+};
+
+export type TrackOutboundStats = {
+  producerId?: string,
+  codec?: RTCRtpCodecParameters,
+  dtlsState?: RTCDtlsTransportState,
+  rtcStats?: RTCOutboundRtpStreamStats,
+};
+
+export type PeerTrackInfo = {
+  trackId: string,
+  readyState: MediaStreamTrackState,
+  isRemote: boolean,
+  kind: MediaKind,
+  label: TrackLabel,
+  paused: boolean,
+  width?: number,
+  height?: number,
+  frameRate?: number,
+  aspectRatio?: number,
+  trackInboundStats?: TrackInboundStats,
+  trackOutboundStats?: TrackOutboundStats,
+};
+
+export type BaseTrackInfo = {
+  trackId: string,
+  readyState: MediaStreamTrackState,
+  kind: MediaKind,
+  label: TrackLabel,
+  paused: boolean,
+  width?: number,
+  height?: number,
+  frameRate?: number,
+  aspectRatio?: number,
+  trackOutboundStats?: TrackOutboundStats,
+};
+
+export type PeerInfo = {
+  id: string,
+  appData: Record<string, unknown>,
+  role: Role,
+  isBroadcaster: boolean;
+  channelIds: string[],
+  appId: string,
+  uid?: string,
+  loginDate: Date,
+  connectionQuality: number,
+  tracks: PeerTrackInfo[],
+};
+
 export type UpdatePeerAppDataPayload = {
   peerId: string,
   appData: Record<string, unknown>,