@webex/plugin-meetings 3.11.0-next.3 → 3.11.0-next.30

package/src/hashTree/types.ts

@@ -10,6 +10,8 @@ export const ObjectType = {
   fullState: 'fullstate',
   links: 'links',
   control: 'controlentry',
+  metadata: 'metadata',
+  embeddedApp: 'embeddedapp',
 } as const;
 
 export type ObjectType = Enum<typeof ObjectType>;
@@ -23,7 +25,9 @@ export const ObjectTypeToLocusKeyMap = {
   [ObjectType.participant]: 'participants', // note: each object is a single participant in participants array
   [ObjectType.mediaShare]: 'mediaShares', // note: each object is a single mediaShare in mediaShares array
   [ObjectType.control]: 'controls', // note: each object is a single control entry in controls object
+  [ObjectType.embeddedApp]: 'embeddedApps', // note: each object is a single embedded app in embeddedApps array
 };
+
 export interface HtMeta {
   elementId: {
     type: ObjectType;

package/src/hashTree/utils.ts

@@ -11,6 +11,15 @@ export function isSelf(object: HashTreeObject) {
   return object.htMeta.elementId.type.toLowerCase() === ObjectType.self;
 }
 
+/**
+ * Checks if the given hash tree object is of type "Metadata"
+ * @param {HashTreeObject} object object to check
+ * @returns {boolean} True if the object is of type "Metadata", false otherwise
+ */
+export function isMetadata(object: HashTreeObject) {
+  return object.htMeta.elementId.type.toLowerCase() === ObjectType.metadata;
+}
+
 /**
  * Analyzes given part of Locus DTO recursively and delete any nested objects that have their own htMeta
  *

package/src/index.ts

@@ -3,7 +3,11 @@ import {registerPlugin} from '@webex/webex-core';
 
 import Meetings from './meetings';
 import config from './config';
-import {LocusRetryStatusInterceptor, LocusRouteTokenInterceptor} from './interceptors';
+import {
+  LocusRetryStatusInterceptor,
+  LocusRouteTokenInterceptor,
+  DataChannelAuthTokenInterceptor,
+} from './interceptors';
 import CaptchaError from './common/errors/captcha-error';
 import IntentToJoinError from './common/errors/intent-to-join';
 import PasswordError from './common/errors/password-error';
@@ -25,6 +29,7 @@ registerPlugin('meetings', Meetings, {
   interceptors: {
     LocusRetryStatusInterceptor: LocusRetryStatusInterceptor.create,
     LocusRouteTokenInterceptor: LocusRouteTokenInterceptor.create,
+    DataChannelAuthTokenInterceptor: DataChannelAuthTokenInterceptor.create,
   },
 });
 

package/src/interceptors/constant.ts

@@ -0,0 +1,6 @@
+const DATA_CHANNEL_AUTH_HEADER = 'Data-Channel-Auth-Token';
+const MAX_RETRY = 1;
+const RETRY_INTERVAL = 2000;
+const RETRY_KEY = '_dcRetryKey';
+
+export {DATA_CHANNEL_AUTH_HEADER, MAX_RETRY, RETRY_INTERVAL, RETRY_KEY};

package/src/interceptors/dataChannelAuthToken.ts

@@ -0,0 +1,142 @@
+/*!
+ * Copyright (c) 2015-2026 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import {Interceptor} from '@webex/http-core';
+import LoggerProxy from '../common/logs/logger-proxy';
+import {DATA_CHANNEL_AUTH_HEADER, MAX_RETRY, RETRY_INTERVAL, RETRY_KEY} from './constant';
+
+/*!
+ * Copyright (c) 2015-2026 Cisco Systems, Inc. See LICENSE file.
+ */
+
+const retryCountMap = new Map();
+interface HttpLikeError extends Error {
+  statusCode?: number;
+  original?: any;
+}
+/**
+ * @class
+ */
+export default class DataChannelAuthTokenInterceptor extends Interceptor {
+  private _refreshDataChannelToken: () => Promise<string>;
+  private _isDataChannelTokenEnabled: () => Promise<boolean>;
+  constructor(options) {
+    super(options);
+
+    this._refreshDataChannelToken = options.refreshDataChannelToken;
+    this._isDataChannelTokenEnabled = options.isDataChannelTokenEnabled;
+  }
+
+  /**
+   * @returns {DataChannelAuthTokenInterceptor}
+   */
+  static create() {
+    // @ts-ignore
+    return new DataChannelAuthTokenInterceptor({
+      webex: this,
+
+      isDataChannelTokenEnabled: async () => {
+        // @ts-ignore
+        return this.internal.llm.isDataChannelTokenEnabled();
+      },
+
+      refreshDataChannelToken: async () => {
+        // @ts-ignore
+        const {body} = await this.internal.llm.refreshDataChannelToken();
+        const {datachannelToken, dataChannelTokenType} = body ?? {};
+
+        // @ts-ignore
+        this.internal.llm.setDatachannelToken(datachannelToken, dataChannelTokenType);
+
+        return datachannelToken;
+      },
+    });
+  }
+
+  private getRetryKey(options) {
+    if (!options[RETRY_KEY]) {
+      options[RETRY_KEY] = `${Date.now()}-${Math.random()}`;
+    }
+
+    return options[RETRY_KEY];
+  }
+
+  // Helper function to get header value case insensitively
+  private getHeader(headers: Record<string, string>, name: string) {
+    const key = Object.keys(headers).find((k) => k.toLowerCase() === name.toLowerCase());
+
+    return key ? headers[key] : undefined;
+  }
+
+  /**
+   * Intercept responses and, on 401/403 with `Data-Channel-Auth-Token` header,
+   * attempt to refresh the data channel token and retry the original request once.
+   *
+   * @param {Object} options
+   * @param {Object} reason
+   * @returns {Promise<HttpResponse>}
+   */
+  async onResponseError(options, reason) {
+    const token = this.getHeader(options.headers, DATA_CHANNEL_AUTH_HEADER);
+    const enabled = await this._isDataChannelTokenEnabled();
+
+    if (!token || !enabled) {
+      return Promise.reject(reason);
+    }
+
+    if (reason.statusCode !== 401 && reason.statusCode !== 403) {
+      return Promise.reject(reason);
+    }
+
+    const key = this.getRetryKey(options);
+    const retryCount = retryCountMap.get(key) || 0;
+
+    if (retryCount >= MAX_RETRY) {
+      LoggerProxy.logger.error(`data channel token refresh exceeded max retry (${MAX_RETRY})`);
+      retryCountMap.delete(key);
+
+      return Promise.reject(reason);
+    }
+
+    retryCountMap.set(key, retryCount + 1);
+
+    return this.refreshTokenAndRetryWithDelay(options);
+  }
+
+  /**
+   * Retry the failed data channel request after a delay.
+   * Refreshes the Data-Channel-Auth-Token and re-sends the original request.
+   *
+   * @param {Object} options - Original request options.
+   * @returns {Promise<HttpResponse>} - Resolves on successful retry.
+   */
+  refreshTokenAndRetryWithDelay(options) {
+    return new Promise((resolve, reject) => {
+      setTimeout(async () => {
+        const key = this.getRetryKey(options);
+        try {
+          const newToken = await this._refreshDataChannelToken();
+
+          options.headers[DATA_CHANNEL_AUTH_HEADER] = newToken;
+
+          // @ts-ignore
+          const res = await this.webex.request(options);
+          retryCountMap.delete(key);
+
+          resolve(res);
+        } catch (e) {
+          retryCountMap.delete(key);
+
+          const msg = e?.message || String(e);
+
+          const err: HttpLikeError = new Error(`DataChannel token refresh failed: ${msg}`);
+          err.statusCode = e?.statusCode;
+          err.original = e;
+
+          reject(err);
+        }
+      }, RETRY_INTERVAL);
+    });
+  }
+}

package/src/interceptors/index.ts

@@ -1,4 +1,5 @@
 import LocusRetryStatusInterceptor from './locusRetry';
 import LocusRouteTokenInterceptor from './locusRouteToken';
+import DataChannelAuthTokenInterceptor from './dataChannelAuthToken';
 
-export {LocusRetryStatusInterceptor, LocusRouteTokenInterceptor};
+export {LocusRetryStatusInterceptor, LocusRouteTokenInterceptor, DataChannelAuthTokenInterceptor};

package/src/locus-info/index.ts

@@ -35,10 +35,11 @@ import HashTreeParser, {
   DataSet,
   HashTreeMessage,
   LocusInfoUpdateType,
+  Metadata,
 } from '../hashTree/hashTreeParser';
 import {HashTreeObject, ObjectType, ObjectTypeToLocusKeyMap} from '../hashTree/types';
-import {isSelf} from '../hashTree/utils';
-import {Links, LocusDTO, LocusFullState} from './types';
+import {isMetadata} from '../hashTree/utils';
+import {Links, LocusDTO} from './types';
 
 export type LocusLLMEvent = {
   data: {
@@ -52,6 +53,7 @@ export type LocusLLMEvent = {
 const LocusDtoTopLevelKeys = [
   'controls',
   'fullState',
+  'embeddedApps',
   'host',
   'info',
   'links',
@@ -69,6 +71,7 @@ const LocusDtoTopLevelKeys = [
 export type LocusApiResponseBody = {
   dataSets?: DataSet[];
   locus: LocusDTO; // this LocusDTO here might not be the full one (for example it won't have all the participants, but it should have self)
+  metadata?: Metadata;
 };
 
 const LocusObjectStateAfterUpdates = {
@@ -239,7 +242,7 @@ export default class LocusInfo extends EventsScope {
             'Locus-info:index#doLocusSync --> got full DTO when we asked for delta'
           );
         }
-        meeting.locusInfo.onFullLocus(res.body);
+        meeting.locusInfo.onFullLocus('classic Locus sync', res.body);
       })
       .catch((e) => {
         LoggerProxy.logger.info(
@@ -362,17 +365,21 @@ export default class LocusInfo extends EventsScope {
    */
   private createHashTreeParser({
     initialLocus,
+    metadata,
   }: {
     initialLocus: {
       dataSets: Array<DataSet>;
       locus: any;
     };
+    metadata: Metadata;
   }) {
     return new HashTreeParser({
       initialLocus,
+      metadata,
       webexRequest: this.webex.request.bind(this.webex),
       locusInfoUpdateCallback: this.updateFromHashTree.bind(this),
       debugId: `HT-${this.meetingId.substring(0, 4)}`,
+      excludedDataSets: this.webex.config.meetings.locus?.excludedDataSets,
     });
   }
 
@@ -387,6 +394,7 @@ export default class LocusInfo extends EventsScope {
           trigger: 'join-response';
           locus: LocusDTO;
           dataSets?: DataSet[];
+          metadata?: Metadata;
         }
       | {
           trigger: 'locus-message';
@@ -401,28 +409,33 @@ export default class LocusInfo extends EventsScope {
     switch (data.trigger) {
       case 'locus-message':
         if (data.hashTreeMessage) {
-          // we need the SELF object to be in the received message, because it contains visibleDataSets
+          // we need the Metadata object to be in the received message, because it contains visibleDataSets
           // and these are needed to initialize all the hash trees
-          const selfObject = data.hashTreeMessage.locusStateElements?.find((el) => isSelf(el));
+          const metadataObject = data.hashTreeMessage.locusStateElements?.find((el) =>
+            isMetadata(el)
+          );
 
-          if (!selfObject?.data?.visibleDataSets) {
+          if (!metadataObject?.data?.visibleDataSets) {
             LoggerProxy.logger.warn(
-              `Locus-info:index#initialSetup --> cannot initialize HashTreeParser, SELF object with visibleDataSets is missing in the message`
+              `Locus-info:index#initialSetup --> cannot initialize HashTreeParser, Metadata object with visibleDataSets is missing in the message`
             );
 
-            throw new Error('SELF object with visibleDataSets is missing in the message');
+            throw new Error('Metadata object with visibleDataSets is missing in the message');
           }
 
           LoggerProxy.logger.info(
             'Locus-info:index#initialSetup --> creating HashTreeParser from message'
           );
           // first create the HashTreeParser, but don't initialize it with any data yet
-          // pass just a fake locus that contains only the visibleDataSets
           this.hashTreeParser = this.createHashTreeParser({
             initialLocus: {
-              locus: {self: {visibleDataSets: selfObject.data.visibleDataSets}},
+              locus: null,
               dataSets: [], // empty, because they will be populated in initializeFromMessage() call  // dataSets: data.hashTreeMessage.dataSets,
             },
+            metadata: {
+              htMeta: metadataObject.htMeta,
+              visibleDataSets: metadataObject.data.visibleDataSets,
+            },
           });
 
           // now handle the message - that should populate all the visible datasets
@@ -430,12 +443,12 @@ export default class LocusInfo extends EventsScope {
         } else {
           // "classic" Locus case, no hash trees involved
           this.updateLocusCache(data.locus);
-          this.onFullLocus(data.locus, undefined);
+          this.onFullLocus('classic locus message', data.locus, undefined);
         }
         break;
       case 'join-response':
         this.updateLocusCache(data.locus);
-        this.onFullLocus(data.locus, undefined, data.dataSets);
+        this.onFullLocus('join response', data.locus, undefined, data.dataSets, data.metadata);
         break;
       case 'get-loci-response':
         if (data.locus?.links?.resources?.visibleDataSets?.url) {
@@ -443,12 +456,12 @@ export default class LocusInfo extends EventsScope {
             'Locus-info:index#initialSetup --> creating HashTreeParser from get-loci-response'
           );
           // first create the HashTreeParser, but don't initialize it with any data yet
-          // pass just a fake locus that contains only the visibleDataSets
           this.hashTreeParser = this.createHashTreeParser({
             initialLocus: {
-              locus: {self: {visibleDataSets: data.locus?.self?.visibleDataSets}},
+              locus: null,
               dataSets: [], // empty, because we don't have them yet
             },
+            metadata: null, // get-loci-response doesn't contain Metadata object
           });
 
           // now initialize all the data
@@ -456,7 +469,7 @@ export default class LocusInfo extends EventsScope {
         } else {
           // "classic" Locus case, no hash trees involved
           this.updateLocusCache(data.locus);
-          this.onFullLocus(data.locus, undefined);
+          this.onFullLocus('classic get-loci-response', data.locus, undefined);
         }
     }
     // Change it to true after it receives it first locus object
@@ -571,6 +584,31 @@ export default class LocusInfo extends EventsScope {
           );
         }
         break;
+      case ObjectType.embeddedApp:
+        if (object.data) {
+          LoggerProxy.logger.info(
+            `Locus-info:index#updateLocusFromHashTreeObject --> embeddedApp id=${object.htMeta.elementId.id} url='${object.data.url}' updated version=${object.htMeta.elementId.version}:`,
+            object.data
+          );
+          const existingEmbeddedApp = locus.embeddedApps?.find(
+            (ms) => ms.htMeta.elementId.id === object.htMeta.elementId.id
+          );
+
+          if (existingEmbeddedApp) {
+            Object.assign(existingEmbeddedApp, object.data);
+          } else {
+            locus.embeddedApps = locus.embeddedApps || [];
+            locus.embeddedApps.push(object.data);
+          }
+        } else {
+          LoggerProxy.logger.info(
+            `Locus-info:index#updateLocusFromHashTreeObject --> embeddedApp id=${object.htMeta.elementId.id} removed, version=${object.htMeta.elementId.version}`
+          );
+          locus.embeddedApps = locus.embeddedApps?.filter(
+            (ms) => ms.htMeta.elementId.id !== object.htMeta.elementId.id
+          );
+        }
+        break;
       case ObjectType.participant:
         LoggerProxy.logger.info(
           `Locus-info:index#updateLocusFromHashTreeObject --> participant id=${
@@ -643,6 +681,12 @@ export default class LocusInfo extends EventsScope {
           }
         }
         break;
+      case ObjectType.metadata:
+        LoggerProxy.logger.info(
+          `Locus-info:index#updateLocusFromHashTreeObject --> metadata object updated to version ${object.htMeta.elementId.version}`
+        );
+        // we don't use hash tree metadata right now for anything, it's mainly used internally by HashTreeParser
+        break;
       default:
         LoggerProxy.logger.warn(
           `Locus-info:index#updateLocusFromHashTreeObject --> received unsupported object type ${type}`
@@ -815,8 +859,18 @@ export default class LocusInfo extends EventsScope {
         data.stateElementsMessage as HashTreeMessage
       );
     } else {
-      // eslint-disable-next-line @typescript-eslint/no-shadow
       const {eventType} = data;
+
+      if (eventType === LOCUSEVENT.HASH_TREE_DATA_UPDATED) {
+        // this can happen when we get an event before join http response
+        // it's OK to just ignore it
+        LoggerProxy.logger.info(
+          `Locus-info:index#parse --> received locus hash tree event before hashTreeParser is created`
+        );
+
+        return;
+      }
+
       const locus = this.getTheLocusToUpdate(data.locus);
       LoggerProxy.logger.info(`Locus-info:index#parse --> received locus data: ${eventType}`);
 
@@ -837,17 +891,11 @@ export default class LocusInfo extends EventsScope {
         case LOCUSEVENT.PARTICIPANT_DECLINED:
         case LOCUSEVENT.FLOOR_GRANTED:
         case LOCUSEVENT.FLOOR_RELEASED:
-          this.onFullLocus(locus, eventType);
+          this.onFullLocus(`classic locus event ${eventType}`, locus, eventType);
           break;
         case LOCUSEVENT.DIFFERENCE:
           this.handleLocusDelta(locus, meeting);
           break;
-        case LOCUSEVENT.HASH_TREE_DATA_UPDATED:
-          this.sendClassicVsHashTreeMismatchMetric(
-            meeting,
-            `got ${eventType}, expected classic events`
-          );
-          break;
 
         default:
           // Why will there be a event with no eventType ????
@@ -871,22 +919,35 @@ export default class LocusInfo extends EventsScope {
   /**
    * Function for handling full locus when it's using hash trees (so not the "classic" one).
    *
+   * @param {string} debugText string explaining the trigger for this call, added to logs for debugging purposes
    * @param {object} locus locus object
+   * @param {object} metadata locus hash trees metadata
    * @param {string} eventType locus event
    * @param {DataSet[]} dataSets
    * @returns {void}
    */
-  private onFullLocusWithHashTrees(locus: any, eventType?: string, dataSets?: Array<DataSet>) {
+  private onFullLocusWithHashTrees(
+    debugText: string,
+    locus: any,
+    metadata: Metadata,
+    eventType?: string,
+    dataSets?: Array<DataSet>
+  ) {
     if (!this.hashTreeParser) {
-      LoggerProxy.logger.info(`Locus-info:index#onFullLocus --> creating hash tree parser`);
       LoggerProxy.logger.info(
-        'Locus-info:index#onFullLocus --> dataSets:',
+        `Locus-info:index#onFullLocus (${debugText}) --> creating hash tree parser`
+      );
+      LoggerProxy.logger.info(
+        `Locus-info:index#onFullLocus (${debugText}) --> dataSets:`,
         dataSets,
         ' and locus:',
-        locus
+        locus,
+        ' and metadata:',
+        metadata
       );
       this.hashTreeParser = this.createHashTreeParser({
         initialLocus: {locus, dataSets},
+        metadata,
       });
       this.onFullLocusCommon(locus, eventType);
     } else {
@@ -894,23 +955,24 @@ export default class LocusInfo extends EventsScope {
       // so treat it like if we just got it in any api response
 
       LoggerProxy.logger.info(
-        'Locus-info:index#onFullLocus --> hash tree parser already exists, handling it like a normal API response'
+        `Locus-info:index#onFullLocus (${debugText}) --> hash tree parser already exists, handling it like a normal API response`
       );
-      this.handleLocusAPIResponse(undefined, {dataSets, locus});
+      this.handleLocusAPIResponse(undefined, {dataSets, locus, metadata});
     }
   }
 
   /**
    * Function for handling full locus when it's the "classic" one (not hash trees)
    *
+   * @param {string} debugText string explaining the trigger for this call, added to logs for debugging purposes
    * @param {object} locus locus object
    * @param {string} eventType locus event
    * @returns {void}
    */
-  private onFullLocusClassic(locus: any, eventType?: string) {
+  private onFullLocusClassic(debugText: string, locus: any, eventType?: string) {
     if (!this.locusParser.isNewFullLocus(locus)) {
       LoggerProxy.logger.info(
-        `Locus-info:index#onFullLocus --> ignoring old full locus DTO, eventType=${eventType}`
+        `Locus-info:index#onFullLocus (${debugText}) --> ignoring old full locus DTO, eventType=${eventType}`
       );
 
       return;
@@ -920,24 +982,37 @@ export default class LocusInfo extends EventsScope {
 
   /**
    * updates the locus with full locus object
+   * @param {string} debugText string explaining the trigger for this call, added to logs for debugging purposes
    * @param {object} locus locus object
    * @param {string} eventType locus event
    * @param {DataSet[]} dataSets
+   * @param {object} metadata locus hash trees metadata
    * @returns {object} null
    * @memberof LocusInfo
    */
-  onFullLocus(locus: any, eventType?: string, dataSets?: Array<DataSet>) {
+  onFullLocus(
+    debugText: string,
+    locus: any,
+    eventType?: string,
+    dataSets?: Array<DataSet>,
+    metadata?: Metadata
+  ) {
     if (!locus) {
       LoggerProxy.logger.error(
-        'Locus-info:index#onFullLocus --> object passed as argument was invalid, continuing.'
+        `Locus-info:index#onFullLocus (${debugText}) --> object passed as argument was invalid, continuing.`
       );
     }
 
     if (dataSets) {
+      if (!metadata) {
+        throw new Error(
+          `Locus-info:index#onFullLocus (${debugText}) --> hash tree metadata is missing with full Locus`
+        );
+      }
       // this is the new hashmap Locus DTO format (only applicable to webinars for now)
-      this.onFullLocusWithHashTrees(locus, eventType, dataSets);
+      this.onFullLocusWithHashTrees(debugText, locus, metadata, eventType, dataSets);
     } else {
-      this.onFullLocusClassic(locus, eventType);
+      this.onFullLocusClassic(debugText, locus, eventType);
     }
   }
 

package/src/locus-info/types.ts

@@ -19,6 +19,7 @@ export type Links = {
 
 export type LocusDTO = {
   controls?: any;
+  embeddedApps?: any[];
   fullState?: LocusFullState;
   host?: {
     id: string;

package/src/media/MediaConnectionAwaiter.ts

@@ -2,9 +2,12 @@ import {Defer} from '@webex/common';
 import {ConnectionState, MediaConnectionEventNames} from '@webex/internal-media-core';
 import LoggerProxy from '../common/logs/logger-proxy';
 import {ICE_AND_DTLS_CONNECTION_TIMEOUT} from '../constants';
+import BEHAVIORAL_METRICS from '../metrics/constants';
+import Metrics from '../metrics';
 
 export interface MediaConnectionAwaiterProps {
   webrtcMediaConnection: any;
+  correlationId: string;
 }
 
 /**
@@ -16,6 +19,7 @@ export default class MediaConnectionAwaiter {
   private defer: Defer;
   private retried: boolean;
   private iceConnected: boolean;
+  private correlationId: string;
   private onTimeoutCallback: () => void;
   private peerConnectionStateCallback: () => void;
   private iceConnectionStateCallback: () => void;
@@ -24,11 +28,12 @@ export default class MediaConnectionAwaiter {
   /**
    * @param {MediaConnectionAwaiterProps} mediaConnectionAwaiterProps
    */
-  constructor({webrtcMediaConnection}: MediaConnectionAwaiterProps) {
+  constructor({webrtcMediaConnection, correlationId}: MediaConnectionAwaiterProps) {
     this.webrtcMediaConnection = webrtcMediaConnection;
     this.defer = new Defer();
     this.retried = false;
     this.iceConnected = false;
+    this.correlationId = correlationId;
     this.onTimeoutCallback = this.onTimeout.bind(this);
     this.peerConnectionStateCallback = this.peerConnectionStateHandler.bind(this);
     this.iceConnectionStateCallback = this.iceConnectionStateHandler.bind(this);
@@ -175,6 +180,32 @@ export default class MediaConnectionAwaiter {
     this.timer = setTimeout(this.onTimeoutCallback, ICE_AND_DTLS_CONNECTION_TIMEOUT);
   }
 
+  /**
+   * sends a metric with some additional info that might help debugging
+   * issues where browser doesn't update the RTCPeerConnection's iceConnectionState or connectionState
+   *
+   * @returns {void}
+   */
+  async sendMetric() {
+    const stats = await this.webrtcMediaConnection.getStats();
+
+    // in theory we can end up with more than one transport report in the stats,
+    // but for the purpose of this metric it's fine to just use the first one
+    const transportReports = Array.from(
+      stats.values().filter((report) => report.type === 'transport')
+    ) as Record<string, number | string>[];
+
+    Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEDIA_STILL_NOT_CONNECTED, {
+      correlation_id: this.correlationId,
+      numTransports: transportReports.length,
+      dtlsState: transportReports[0]?.dtlsState,
+      iceState: transportReports[0]?.iceState,
+      packetsSent: transportReports[0]?.packetsSent,
+      packetsReceived: transportReports[0]?.packetsReceived,
+      dataChannelState: this.webrtcMediaConnection.multistreamConnection?.dataChannel?.readyState,
+    });
+  }
+
   /**
    * Function called when the timeout is reached.
    *
@@ -189,6 +220,8 @@ export default class MediaConnectionAwaiter {
       return;
     }
 
+    this.sendMetric();
+
     if (!this.isIceGatheringCompleted()) {
       if (!this.retried) {
         LoggerProxy.logger.warn(
@@ -226,8 +259,15 @@ export default class MediaConnectionAwaiter {
    */
   waitForMediaConnectionConnected(): Promise<void> {
     if (this.isConnected()) {
+      LoggerProxy.logger.log(
+        'Media:MediaConnectionAwaiter#waitForMediaConnectionConnected --> Already connected'
+      );
+
       return Promise.resolve();
     }
+    LoggerProxy.logger.log(
+      'Media:MediaConnectionAwaiter#waitForMediaConnectionConnected --> Waiting for media connection to be connected'
+    );
 
     this.webrtcMediaConnection.on(
       MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED,

package/src/media/properties.ts

@@ -196,11 +196,13 @@ export default class MediaProperties {
   /**
    * Waits for the webrtc media connection to be connected.
    *
+   * @param {string} correlationId
    * @returns {Promise<void>}
    */
-  waitForMediaConnectionConnected(): Promise<void> {
+  waitForMediaConnectionConnected(correlationId: string): Promise<void> {
     const mediaConnectionAwaiter = new MediaConnectionAwaiter({
       webrtcMediaConnection: this.webrtcMediaConnection,
+      correlationId,
     });
 
     return mediaConnectionAwaiter.waitForMediaConnectionConnected();