@webex/plugin-meetings 3.0.0-beta.23 → 3.0.0-beta.231

package/src/reachability/request.ts

@@ -1,5 +1,5 @@
 import LoggerProxy from '../common/logs/logger-proxy';
-import {HTTP_VERBS, RESOURCE, API} from '../constants';
+import {HTTP_VERBS, RESOURCE, API, IP_VERSION} from '../constants';
 
 export interface ClusterNode {
   isVideoMesh: boolean;
@@ -28,31 +28,40 @@ class ReachabilityRequest {
   }
 
   /**
-   * gets the cluster information
+   * Gets the cluster information
    *
-   * @param {boolean} includeVideoMesh whether to include the video mesh clusters in the result or not
+   * @param {IP_VERSION} ipVersion information about current ip network we're on
    * @returns {Promise}
    */
-  getClusters = (): Promise<ClusterList> =>
+  getClusters = (ipVersion: IP_VERSION): Promise<{clusters: ClusterList; joinCookie: any}> =>
     this.webex
       .request({
         method: HTTP_VERBS.GET,
         shouldRefreshAccessToken: false,
         api: API.CALLIOPEDISCOVERY,
         resource: RESOURCE.CLUSTERS,
+        qs: {
+          JCSupport: 1,
+          ipver: ipVersion,
+        },
       })
       .then((res) => {
-        const {clusters} = res.body;
+        const {clusters, joinCookie} = res.body;
 
         Object.keys(clusters).forEach((key) => {
           clusters[key].isVideoMesh = res.body.clusterClasses?.hybridMedia?.includes(key);
         });
 
         LoggerProxy.logger.log(
-          `Reachability:request#getClusters --> get clusters successful:${JSON.stringify(clusters)}`
+          `Reachability:request#getClusters --> get clusters (ipver=${ipVersion}) successful:${JSON.stringify(
+            clusters
+          )}`
         );
 
-        return clusters;
+        return {
+          clusters,
+          joinCookie,
+        };
       });
 
   /**

package/src/reconnection-manager/index.ts

@@ -18,10 +18,9 @@ import {
 import BEHAVIORAL_METRICS from '../metrics/constants';
 import ReconnectionError from '../common/errors/reconnection';
 import ReconnectInProgress from '../common/errors/reconnection-in-progress';
-import {eventType, reconnection, errorObjects} from '../metrics/config';
-import Media from '../media';
 import Metrics from '../metrics';
 import Meeting from '../meeting';
+import {MediaRequestManager} from '../multistream/mediaRequestManager';
 
 /**
  * Used to indicate that the reconnect logic needs to be retried.
@@ -231,6 +230,32 @@ export default class ReconnectionManager {
     this.meeting = null;
   }
 
+  /**
+   * Stop the local share track.
+   *
+   * @param {string} reason a {@link SHARE_STOPPED_REASON}
+   * @returns {undefined}
+   * @private
+   * @memberof ReconnectionManager
+   */
+  private async stopLocalShareTrack(reason: string) {
+    await this.meeting.unpublishTracks([
+      this.meeting.mediaProperties.shareVideoTrack,
+      this.meeting.mediaProperties.shareAudioTrack,
+    ]);
+    Trigger.trigger(
+      this.meeting,
+      {
+        file: 'reconnection-manager/index',
+        function: 'stopLocalShareTrack',
+      },
+      EVENT_TRIGGERS.MEETING_STOPPED_SHARING_LOCAL,
+      {
+        reason,
+      }
+    );
+  }
+
   /**
    * @public
    * @memberof ReconnectionManager
@@ -302,9 +327,13 @@ export default class ReconnectionManager {
       LoggerProxy.logger.info(
         'ReconnectionManager:index#reconnect --> Sending reconnect start metric.'
       );
-      Metrics.postEvent({
-        event: eventType.MEDIA_RECONNECTING,
-        meeting: this.meeting,
+
+      // @ts-ignore
+      this.webex.internal.newMetrics.submitClientEvent({
+        name: 'client.media.reconnecting',
+        options: {
+          meetingId: this.meeting.id,
+        },
       });
     }
 
@@ -314,10 +343,16 @@ export default class ReconnectionManager {
         LoggerProxy.logger.info(
           'ReconnectionManager:index#reconnect --> Sending reconnect success metric.'
         );
-        Metrics.postEvent({
-          event: eventType.MEDIA_RECOVERED,
-          meeting: this.meeting,
-          data: {recoveredBy: reconnection.RECOVERED_BY_NEW},
+
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.media.recovered',
+          payload: {
+            recoveredBy: 'new',
+          },
+          options: {
+            meetingId: this.meeting.id,
+          },
         });
       })
       .catch((reconnectError) => {
@@ -341,23 +376,24 @@ export default class ReconnectionManager {
           'ReconnectionManager:index#reconnect --> Sending reconnect abort metric.'
         );
 
-        const reconnectMetric = {
-          event: eventType.CALL_ABORTED,
-          meeting: this.meeting,
-          data: {
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.call.aborted',
+          payload: {
             errors: [
               {
-                category: errorObjects.category.expected,
+                category: 'expected',
                 errorCode: 2008,
                 fatal: true,
-                name: errorObjects.name.mediaEngine,
+                name: 'media-engine',
                 shownToUser: false,
               },
             ],
           },
-        };
-
-        Metrics.postEvent(reconnectMetric);
+          options: {
+            meetingId: this.meeting.id,
+          },
+        });
         if (reconnectError instanceof NeedsRejoinError) {
           // send call aborded event with catogery as expected as we are trying to rejoin
 
@@ -385,6 +421,12 @@ export default class ReconnectionManager {
       'ReconnectionManager:index#executeReconnection --> Attempting to reconnect to meeting.'
     );
 
+    const wasSharing = this.meeting.shareStatus === SHARE_STATUS.LOCAL_SHARE_ACTIVE;
+
+    if (wasSharing) {
+      await this.stopLocalShareTrack(SHARE_STOPPED_REASON.MEDIA_RECONNECTION);
+    }
+
     if (networkDisconnect) {
       try {
         await this.reconnectMercuryWebSocket();
@@ -401,8 +443,6 @@ export default class ReconnectionManager {
       }
     }
 
-    const wasSharing = this.meeting.shareStatus === SHARE_STATUS.LOCAL_SHARE_ACTIVE;
-
     try {
       LoggerProxy.logger.info(
         'ReconnectionManager:index#executeReconnection --> Updating meeting data from server.'
@@ -420,10 +460,10 @@ export default class ReconnectionManager {
     // So that on rejoin it known what parametrs it was using
     if (!this.meeting || !this.webex.meetings.getMeetingByType(_ID_, this.meeting.id)) {
       LoggerProxy.logger.info(
-        'ReconnectionManager:index#executeReconnection --> Meeting got deleted due to inactivity or ended remotely '
+        'ReconnectionManager:index#executeReconnection --> Meeting got deleted due to inactivity or ended remotely.'
       );
 
-      throw new Error('Unable to rejoin a meeting already ended or inactive .');
+      throw new Error('Unable to rejoin a meeting already ended or inactive.');
     }
 
     LoggerProxy.logger.info(
@@ -475,24 +515,7 @@ export default class ReconnectionManager {
       LoggerProxy.logger.info('ReconnectionManager:index#rejoinMeeting --> meeting rejoined');
 
       if (wasSharing) {
-        // Stop the share streams if user tried to rejoin
-        Media.stopTracks(this.meeting.mediaProperties.shareTrack);
-        this.meeting.isSharing = false;
-        if (this.shareStatus === SHARE_STATUS.LOCAL_SHARE_ACTIVE) {
-          this.meeting.shareStatus = SHARE_STATUS.NO_SHARE;
-        }
-        this.meeting.mediaProperties.mediaDirection.sendShare = false;
-        Trigger.trigger(
-          this.meeting,
-          {
-            file: 'reconnection-manager/index',
-            function: 'rejoinMeeting',
-          },
-          EVENT_TRIGGERS.MEETING_STOPPED_SHARING_LOCAL,
-          {
-            reason: SHARE_STOPPED_REASON.MEETING_REJOIN,
-          }
-        );
+        await this.stopLocalShareTrack(SHARE_STOPPED_REASON.MEETING_REJOIN);
       }
     } catch (joinError) {
       this.rejoinAttempts += 1;
@@ -555,9 +578,11 @@ export default class ReconnectionManager {
 
     // resend media requests
     if (this.meeting.isMultistream) {
-      Object.values(this.meeting.mediaRequestManagers).forEach((mediaRequestManager) =>
-        // @ts-ignore - Fix type
-        mediaRequestManager.commit()
+      Object.values(this.meeting.mediaRequestManagers).forEach(
+        (mediaRequestManager: MediaRequestManager) => {
+          mediaRequestManager.clearPreviousRequests();
+          mediaRequestManager.commit();
+        }
       );
     }
   }

package/src/recording-controller/index.ts

@@ -1,5 +1,5 @@
 import PermissionError from '../common/errors/permission';
-import {CONTROLS, HTTP_VERBS} from '../constants';
+import {CONTROLS, HTTP_VERBS, SELF_POLICY} from '../constants';
 import MeetingRequest from '../meeting/request';
 import RecordingAction from './enums';
 import Util from './util';
@@ -28,6 +28,14 @@ export default class RecordingController {
    */
   private displayHints: Array<string> = [];
 
+  /**
+   * @instance
+   * @type {Object}
+   * @private
+   * @memberof RecordingInfo
+   */
+  private selfUserPolicies: Record<SELF_POLICY, boolean>;
+
   /**
    * @instance
    * @type {string}
@@ -81,7 +89,6 @@ export default class RecordingController {
 
   /**
    * @param {MeetingRequest} request
-   * @param {LocusInfo} info
    * @returns {void}
    * @private
    * @memberof RecordingController
@@ -126,6 +133,16 @@ export default class RecordingController {
     this.displayHints = hints;
   }
 
+  /**
+   * @param {Object} selfUserPolicies
+   * @returns {void}
+   * @public
+   * @memberof RecordingController
+   */
+  public setUserPolicy(selfUserPolicies: Record<SELF_POLICY, boolean>) {
+    this.selfUserPolicies = selfUserPolicies;
+  }
+
   /**
    * @param {string} id
    * @returns {void}
@@ -264,7 +281,7 @@ export default class RecordingController {
     );
 
     // assumes action is proper cased (i.e., Example)
-    if (Util?.[`canUser${action}`](this.displayHints)) {
+    if (Util?.[`canUser${action}`](this.displayHints, this.selfUserPolicies)) {
       if (this.serviceUrl) {
         return this.recordingService(action);
       }

package/src/recording-controller/util.ts

@@ -1,17 +1,34 @@
-import {DISPLAY_HINTS} from '../constants';
+import {DISPLAY_HINTS, SELF_POLICY} from '../constants';
 import RecordingAction from './enums';
+import MeetingUtil from '../meeting/util';
 
-const canUserStart = (displayHints: Array<string>): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_START);
+const canUserStart = (
+  displayHints: Array<string>,
+  userPolicies: Record<SELF_POLICY, boolean>
+): boolean =>
+  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_START) &&
+  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
 
-const canUserPause = (displayHints: Array<string>): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_PAUSE);
+const canUserPause = (
+  displayHints: Array<string>,
+  userPolicies: Record<SELF_POLICY, boolean>
+): boolean =>
+  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_PAUSE) &&
+  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
 
-const canUserResume = (displayHints: Array<string>): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_RESUME);
+const canUserResume = (
+  displayHints: Array<string>,
+  userPolicies: Record<SELF_POLICY, boolean>
+): boolean =>
+  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_RESUME) &&
+  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
 
-const canUserStop = (displayHints: Array<string>): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_STOP);
+const canUserStop = (
+  displayHints: Array<string>,
+  userPolicies: Record<SELF_POLICY, boolean>
+): boolean =>
+  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_STOP) &&
+  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
 
 const extractLocusId = (url: string) => {
   return url?.split('/').pop();

package/src/roap/index.ts

@@ -98,11 +98,9 @@ export default class Roap extends StatelessWebexPlugin {
           roapMessage,
           locusSelfUrl: meeting.selfUrl,
           mediaId: options.mediaId,
-          correlationId: options.correlationId,
-          audioMuted: meeting.isAudioMuted(),
-          videoMuted: meeting.isVideoMuted(),
           meetingId: meeting.id,
-          preferTranscoding: !meeting.isMultistream,
+          locusMediaRequest: meeting.locusMediaRequest,
+          ipVersion: meeting.webex.meetings.reachability.getIpVersion(),
         })
         .then(() => {
           LoggerProxy.logger.log(`Roap:index#sendRoapOK --> ROAP OK sent with seq ${options.seq}`);
@@ -135,11 +133,9 @@ export default class Roap extends StatelessWebexPlugin {
       roapMessage,
       locusSelfUrl: meeting.selfUrl,
       mediaId: options.mediaId,
-      correlationId: options.correlationId,
-      audioMuted: meeting.isAudioMuted(),
-      videoMuted: meeting.isVideoMuted(),
       meetingId: meeting.id,
-      preferTranscoding: !meeting.isMultistream,
+      locusMediaRequest: meeting.locusMediaRequest,
+      ipVersion: meeting.webex.meetings.reachability.getIpVersion(),
     });
   }
 
@@ -167,11 +163,9 @@ export default class Roap extends StatelessWebexPlugin {
         roapMessage,
         locusSelfUrl: meeting.selfUrl,
         mediaId: options.mediaId,
-        correlationId: options.correlationId,
-        audioMuted: meeting.isAudioMuted(),
-        videoMuted: meeting.isVideoMuted(),
         meetingId: meeting.id,
-        preferTranscoding: !meeting.isMultistream,
+        locusMediaRequest: meeting.locusMediaRequest,
+        ipVersion: meeting.webex.meetings.reachability.getIpVersion(),
       })
       .then(() => {
         LoggerProxy.logger.log(
@@ -199,26 +193,27 @@ export default class Roap extends StatelessWebexPlugin {
     // When reconnecting, it's important that the first roap message being sent out has empty media id.
     // Normally this is the roap offer, but when TURN discovery is enabled,
     // then this is the TURN discovery request message
-    const sendEmptyMediaId = reconnect && !meeting.config.experimental.enableTurnDiscovery;
+    return this.turnDiscovery.isSkipped(meeting).then((isTurnDiscoverySkipped) => {
+      const sendEmptyMediaId = reconnect && isTurnDiscoverySkipped;
 
-    return this.roapRequest
-      .sendRoap({
-        roapMessage,
-        correlationId: meeting.correlationId,
-        locusSelfUrl: meeting.selfUrl,
-        mediaId: sendEmptyMediaId ? '' : meeting.mediaId,
-        audioMuted: meeting.isAudioMuted(),
-        videoMuted: meeting.isVideoMuted(),
-        meetingId: meeting.id,
-        preferTranscoding: !meeting.isMultistream,
-      })
-      .then(({locus, mediaConnections}) => {
-        if (mediaConnections) {
-          meeting.updateMediaConnections(mediaConnections);
-        }
+      return this.roapRequest
+        .sendRoap({
+          roapMessage,
+          locusSelfUrl: meeting.selfUrl,
+          mediaId: sendEmptyMediaId ? '' : meeting.mediaId,
+          meetingId: meeting.id,
+          preferTranscoding: !meeting.isMultistream,
+          locusMediaRequest: meeting.locusMediaRequest,
+          ipVersion: meeting.webex.meetings.reachability.getIpVersion(),
+        })
+        .then(({locus, mediaConnections}) => {
+          if (mediaConnections) {
+            meeting.updateMediaConnections(mediaConnections);
+          }
 
-        return locus;
-      });
+          return locus;
+        });
+    });
   }
 
   /**

package/src/roap/request.ts

@@ -1,25 +1,25 @@
-/* global window */
 // @ts-ignore
 import {StatelessWebexPlugin} from '@webex/webex-core';
 
 import LoggerProxy from '../common/logs/logger-proxy';
-import {MEDIA, HTTP_VERBS, REACHABILITY} from '../constants';
-import Metrics from '../metrics';
-import {eventType} from '../metrics/config';
+import {IP_VERSION, REACHABILITY} from '../constants';
+import {LocusMediaRequest} from '../meeting/locusMediaRequest';
 
 /**
  * @class RoapRequest
  */
 export default class RoapRequest extends StatelessWebexPlugin {
   /**
-   * Joins a meeting via ROAP
+   * Returns reachability data.
    * @param {Object} localSdp
-   * @returns {Promise} returns a promise that resolves/rejects whatever the request does
+   * @returns {Object}
    */
-  async attachRechabilityData(localSdp) {
+  async attachReachabilityData(localSdp) {
+    let joinCookie;
+
     // @ts-ignore
     const reachabilityData = await this.webex.boundedStorage
-      .get(REACHABILITY.namespace, REACHABILITY.localStorage)
+      .get(REACHABILITY.namespace, REACHABILITY.localStorageResult)
       .catch(() => {});
 
     if (reachabilityData) {
@@ -37,7 +37,22 @@ export default class RoapRequest extends StatelessWebexPlugin {
       }
     }
 
-    return localSdp;
+    // @ts-ignore
+    const joinCookieRaw = await this.webex.boundedStorage
+      .get(REACHABILITY.namespace, REACHABILITY.localStorageJoinCookie)
+      .catch(() => {});
+
+    if (joinCookieRaw) {
+      try {
+        joinCookie = JSON.parse(joinCookieRaw);
+      } catch (e) {
+        LoggerProxy.logger.error(
+          `MeetingRequest#constructor --> Error in parsing join cookie data: ${e}`
+        );
+      }
+    }
+
+    return {localSdp, joinCookie};
   }
 
   /**
@@ -47,111 +62,104 @@ export default class RoapRequest extends StatelessWebexPlugin {
    * @param {String} options.locusSelfUrl
    * @param {String} options.mediaId
    * @param {String} options.correlationId
-   * @param {Boolean} options.audioMuted
-   * @param {Boolean} options.videoMuted
    * @param {String} options.meetingId
-   * @param {Boolean} options.preferTranscoding
    * @returns {Promise} returns the response/failure of the request
    */
-  sendRoap(options: {
+  async sendRoap(options: {
     roapMessage: any;
     locusSelfUrl: string;
     mediaId: string;
-    correlationId: string;
-    audioMuted: boolean;
-    videoMuted: boolean;
     meetingId: string;
-    preferTranscoding?: boolean;
+    ipVersion: IP_VERSION;
+    locusMediaRequest?: LocusMediaRequest;
   }) {
-    const {roapMessage, locusSelfUrl, mediaId, correlationId, meetingId} = options;
+    const {roapMessage, locusSelfUrl, mediaId, meetingId, locusMediaRequest, ipVersion} = options;
 
     if (!mediaId) {
-      LoggerProxy.logger.info('Roap:request#sendRoap --> Race Condition /call mediaID not present');
+      LoggerProxy.logger.info('Roap:request#sendRoap --> sending empty mediaID');
     }
 
-    const mediaUrl = `${locusSelfUrl}/${MEDIA}`;
-    // @ts-ignore
-    const deviceUrl = this.webex.internal.device.url;
+    if (!locusMediaRequest) {
+      LoggerProxy.logger.warn(
+        'Roap:request#sendRoap --> locusMediaRequest unavailable, not sending roap'
+      );
+
+      return Promise.reject(new Error('sendRoap called when locusMediaRequest is undefined'));
+    }
+    const {localSdp: localSdpWithReachabilityData, joinCookie} = await this.attachReachabilityData({
+      roapMessage,
+    });
 
     LoggerProxy.logger.info(
-      `Roap:request#sendRoap --> ${mediaUrl} \n ${roapMessage.messageType} \n seq:${roapMessage.seq}`
+      `Roap:request#sendRoap --> ${locusSelfUrl} \n ${roapMessage.messageType} \n seq:${roapMessage.seq}`
     );
 
-    Metrics.postEvent({event: eventType.MEDIA_REQUEST, meetingId});
+    // @ts-ignore
+    this.webex.internal.newMetrics.submitClientEvent({
+      name: 'client.locus.media.request',
+      options: {
+        meetingId,
+      },
+    });
 
-    return this.attachRechabilityData({
-      roapMessage,
-      // eslint-disable-next-line no-warning-comments
-      // TODO: check whats the need for video and audiomute
-      audioMuted: !!options.audioMuted,
-      videoMuted: !!options.videoMuted,
-    }).then((sdpWithReachability) => {
-      // @ts-ignore
-      return this.webex
-        .request({
-          uri: mediaUrl,
-          method: HTTP_VERBS.PUT,
-          body: {
-            device: {
-              url: deviceUrl,
-              // @ts-ignore
-              deviceType: this.config.meetings.deviceType,
-            },
-            correlationId,
-            localMedias: [
-              {
-                localSdp: JSON.stringify(sdpWithReachability),
-                mediaId: options.mediaId,
-              },
-            ],
-            clientMediaPreferences: {
-              preferTranscoding: options.preferTranscoding ?? true,
-            },
+    return locusMediaRequest
+      .send({
+        type: 'RoapMessage',
+        selfUrl: locusSelfUrl,
+        joinCookie,
+        mediaId,
+        roapMessage,
+        reachability: localSdpWithReachabilityData.reachability,
+        ipVersion,
+      })
+      .then((res) => {
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.locus.media.response',
+          options: {
+            meetingId,
           },
-        })
-        .then((res) => {
-          Metrics.postEvent({event: eventType.MEDIA_RESPONSE, meetingId});
-
-          // always it will be the first mediaConnection Object
-          const mediaConnections =
-            res.body.mediaConnections &&
-            res.body.mediaConnections.length > 0 &&
-            res.body.mediaConnections[0];
-
-          LoggerProxy.logger.info(
-            `Roap:request#sendRoap --> response:${JSON.stringify(
-              mediaConnections,
-              null,
-              2
-            )}'\n StatusCode:'${res.statusCode}`
-          );
-          const {locus} = res.body;
-
-          locus.roapSeq = options.roapMessage.seq;
-
-          return {
-            locus,
-            ...(mediaConnections && {mediaConnections: res.body.mediaConnections}),
-          };
-        })
-        .catch((err) => {
-          Metrics.postEvent({
-            event: eventType.MEDIA_RESPONSE,
+        });
+        // always it will be the first mediaConnection Object
+        const mediaConnections =
+          res.body.mediaConnections &&
+          res.body.mediaConnections.length > 0 &&
+          res.body.mediaConnections[0];
+
+        LoggerProxy.logger.debug(
+          `Roap:request#sendRoap --> response:${JSON.stringify(
+            mediaConnections,
+            null,
+            2
+          )}'\n StatusCode:'${res.statusCode}`
+        );
+        const {locus} = res.body;
+
+        locus.roapSeq = options.roapMessage.seq;
+
+        return {
+          locus,
+          ...(mediaConnections && {mediaConnections: res.body.mediaConnections}),
+        };
+      })
+      .catch((err) => {
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.locus.media.response',
+          options: {
             meetingId,
-            data: {error: Metrics.parseLocusError(err, true)},
-          });
-          LoggerProxy.logger.error(
-            `Roap:request#sendRoap --> Error:${JSON.stringify(err, null, 2)}`
-          );
-          LoggerProxy.logger.error(
-            `Roap:request#sendRoapRequest --> errorBody:${JSON.stringify(
-              roapMessage,
-              null,
-              2
-            )} + '\\n mediaId:'${options.mediaId}`
-          );
-          throw err;
+            rawError: err,
+          },
         });
-    });
+        LoggerProxy.logger.error(`Roap:request#sendRoap --> Error:${JSON.stringify(err, null, 2)}`);
+        LoggerProxy.logger.error(
+          `Roap:request#sendRoapRequest --> errorBody:${JSON.stringify(
+            roapMessage,
+            null,
+            2
+          )} + '\\n mediaId:'${options.mediaId}`
+        );
+        throw err;
+      });
   }
 }