@livedigital/client 2.6.0 → 2.7.1-wid-bug-fixes.1

package/dist/types/common.d.ts

@@ -209,3 +209,4 @@ export declare type TransformParams = {
     width?: number;
     height?: number;
 };
+export declare type LogMessageHandler = (msg: any, ...meta: any) => void;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@livedigital/client",
   "author": "vlprojects",
   "license": "MIT",
-  "version": "2.6.0",
+  "version": "2.7.1-wid-bug-fixes.1",
   "private": false,
   "bugs": {
     "url": "https://github.com/vlprojects/livedigital-sdk/issues"
@@ -40,6 +40,7 @@
     ]
   },
   "dependencies": {
+    "@peermetrics/webrtc-stats": "^5.4.0",
     "axios": "^0.21.4",
     "debug": "^4.3.1",
     "mediasoup-client": "^3.6.50",

package/src/engine/Logger.ts

@@ -1,4 +1,5 @@
 import debug from 'debug';
+import { LogMessageHandler } from '../types/common';
 
 const APP_NAME = 'LiveDigital';
 
@@ -9,7 +10,9 @@ class Logger {
 
   private readonly _error: debug.Debugger;
 
-  constructor(prefix?: string) {
+  private readonly onLogMessage: LogMessageHandler;
+
+  constructor(prefix?: string, onLogMessage?: LogMessageHandler) {
     if (prefix) {
       this._debug = debug(`${APP_NAME}:${prefix}`);
       this._warn = debug(`${APP_NAME}:WARN:${prefix}`);
@@ -25,18 +28,27 @@ class Logger {
     this._warn.log = console.warn.bind(console);
     this._error.log = console.error.bind(console);
     /* eslint-enable no-console */
+
+    this.onLogMessage = (msg: any, ...meta: any[]) => {
+      if (typeof onLogMessage === 'function') {
+        onLogMessage(msg, ...meta);
+      }
+    };
   }
 
-  get debug(): debug.Debugger {
-    return this._debug;
+  debug(msg: any, ...meta: any[]): void {
+    this._debug(msg, ...meta);
+    this.onLogMessage(msg, ...meta);
   }
 
-  get warn(): debug.Debugger {
-    return this._warn;
+  warn(msg: any, ...meta: any[]): void {
+    this._warn(msg, ...meta);
+    this.onLogMessage(msg, ...meta);
   }
 
-  get error(): debug.Debugger {
-    return this._error;
+  error(msg: any, ...meta: any[]): void {
+    this._error(msg, ...meta);
+    this.onLogMessage(msg, ...meta);
   }
 }
 

package/src/engine/Peer.ts

@@ -68,6 +68,8 @@ class Peer {
 
   private outgoingConnectionQuality: ConnectionQuality = ConnectionQuality.GOOD;
 
+  private overallConnectionQuality: ConnectionQuality = ConnectionQuality.GOOD;
+
   constructor({
     id,
     channelIds,
@@ -332,10 +334,15 @@ class Peer {
     setTimeout(() => {
       // pick connection (incoming or outgoing) with lower quality
       const connectionQuality = Math.min(this.outgoingConnectionQuality, this.incomingConnectionQuality);
+      if (connectionQuality === this.overallConnectionQuality) {
+        return;
+      }
+
       this.observer.safeEmit(PEER_EVENTS.connectionQualityChanged, {
         connectionQuality,
       });
 
+      this.overallConnectionQuality = connectionQuality;
       this.logger.debug('emitConnectionQuality()', { peer: this, connectionQuality });
     }, 1000);
   }

package/src/engine/index.ts

@@ -10,6 +10,7 @@ import {
   SocketResponse,
   Track,
   TrackLabel,
+  LogMessageHandler,
 } from '../types/common';
 import EnhancedEventEmitter from '../EnhancedEventEmitter';
 import System from './system';
@@ -26,11 +27,13 @@ import { GetNodeRequest } from '../types/network';
 import VideoTrack from './media/tracks/VideoTrack';
 import AudioTrack from './media/tracks/AudioTrack';
 import PeerTrack from './media/tracks/PeerTrack';
+import WebRTCIssueDetector from './wid/WebRTCIssueDetector';
 import { retryAsync } from '../helpers/retry';
 
 type EngineParams = {
   clientEventEmitter: EnhancedEventEmitter,
   network: NetworkParams,
+  onLogMessage?: LogMessageHandler;
 };
 
 class Engine {
@@ -60,8 +63,13 @@ class Engine {
 
   private logger: Logger;
 
+  private webRtcIssueDetector: WebRTCIssueDetector;
+
   constructor(params: EngineParams) {
-    const { clientEventEmitter, network } = params;
+    const {
+      clientEventEmitter,
+      network,
+    } = params;
     this.system = new System({ clientEventEmitter });
     this.media = new Media();
     this.network = new Network(network);
@@ -69,7 +77,15 @@ class Engine {
     this.clientEventEmitter = clientEventEmitter;
     this.channelEventsHandler = new ChannelEventHandler(this);
     this.mediaSoupEventsHandler = new MediaSoupEventHandler(this);
-    this.logger = new Logger('Engine');
+    this.logger = new Logger('Engine', params.onLogMessage);
+    this.webRtcIssueDetector = new WebRTCIssueDetector({
+      onIssue: (issues: any[]) => {
+        issues.forEach((issue) => {
+          this.logger.warn('webRtcIssueDetector', issue);
+        });
+      },
+    });
+
     this.watchSocketState();
   }
 
@@ -78,6 +94,7 @@ class Engine {
       const { rtpCapabilities } = await this.network.socket
         .request('router.getRtpCapabilities') as { rtpCapabilities: RtpCapabilities };
       await this.media.loadDevice(rtpCapabilities);
+      this.webRtcIssueDetector.watchNewPeerConnections();
       await this.network.createSendTransport(this.media.mediasoupDevice);
       await this.network.createRecvTransport(this.media.mediasoupDevice);
       this.initialized = true;
@@ -94,6 +111,8 @@ class Engine {
       this.isJoined = false;
       this.app = undefined;
       this.channel = undefined;
+      this.webRtcIssueDetector.stopWatchingNewPeerConnections();
+      this.webRtcIssueDetector.resetWatchedPeerConnectionsList();
       this.network.socket.disconnect();
       this.peersRepository.clear();
       await this.unpublish();
@@ -488,11 +507,11 @@ class Engine {
   private async performJoin(params: JoinChannelParams): Promise<void> {
     try {
       await this.sendJoinChannelRequestWithRetry(params);
+      this.app = params.appId;
+      this.channel = params.channelId;
       await this.initialize();
       this.channelEventsHandler.subscribeToEvents();
       this.mediaSoupEventsHandler.subscribeToEvents();
-      this.app = params.appId;
-      this.channel = params.channelId;
       this.isJoined = true;
       this.logger.debug(`Successfully joined to ${params.channelId}. Peers in channel:`, this.peersRepository);
     } catch (error) {

package/src/engine/wid/WIDRTCPeerConnection.ts

@@ -0,0 +1,13 @@
+import { WIDWindow } from './types';
+
+class WIDRTCPeerConnection extends RTCPeerConnection {
+  constructor(configuration?: RTCConfiguration) {
+    super(configuration);
+    const { wid: webRTCIssueDetector } = (window as unknown as WIDWindow);
+    if (webRTCIssueDetector) {
+      webRTCIssueDetector.handleNewPeerConnection(this);
+    }
+  }
+}
+
+export default WIDRTCPeerConnection;

package/src/engine/wid/WebRTCIssueDetector.ts

@@ -0,0 +1,110 @@
+import { WebRTCStats, WebRTCStatsEventData } from '@peermetrics/webrtc-stats';
+import WIDRTCPeerConnection from './WIDRTCPeerConnection';
+import { WebRTCIssueEmitter } from './WebRTCIssueEmitter';
+import {
+  WebRTCIssueDetectorConstructorParams,
+  EventType,
+  IssuePayload,
+  WIDWindow,
+  IssueDetector,
+} from './types';
+import QualityLimitationsIssueDetector from './detectors/QualityLimitationsIssueDetector';
+import FramesDroppedIssueDetector from './detectors/FramesDroppedIssueDetector';
+import FramesEncodedSentIssueDetector from './detectors/FramesEncodedSentIssueDetector';
+import NetworkIssueDetector from './detectors/NetworkIssueDetector';
+import NetworkMediaSyncIssueDetector from './detectors/NetworkMediaSyncIssueDetector';
+import AvailableOutgoingBitrateIssueDetector from './detectors/AvailableOutgoingBitrateIssueDetector';
+
+class WebRTCIssueDetector {
+  private readonly webrtcStats: WebRTCStats;
+
+  private readonly webrtcStatsPeerId = 'peerId';
+
+  private readonly getStatsInterval = 5000;
+
+  private readonly detectors: IssueDetector[] = [];
+
+  readonly eventEmitter = new WebRTCIssueEmitter();
+
+  #running = false;
+
+  constructor(params: WebRTCIssueDetectorConstructorParams) {
+    if (params.onIssue) {
+      this.eventEmitter.on(EventType.Issue, params.onIssue);
+    }
+
+    this.webrtcStats = new WebRTCStats({
+      getStatsInterval: this.getStatsInterval,
+    });
+
+    (window as unknown as WIDWindow).wid = this;
+    if (window.RTCPeerConnection) {
+      window.RTCPeerConnection = WIDRTCPeerConnection;
+    }
+
+    this.detectors = [
+      new QualityLimitationsIssueDetector(),
+      new FramesDroppedIssueDetector(),
+      new FramesEncodedSentIssueDetector(),
+      new NetworkIssueDetector(),
+      new NetworkMediaSyncIssueDetector(),
+      new AvailableOutgoingBitrateIssueDetector(),
+    ];
+
+    this.webrtcStats.on('stats', (event) => {
+      this.detectIssues(event.data);
+    });
+  }
+
+  public watchNewPeerConnections(): void {
+    if (this.#running) {
+      throw new Error('WebRTCIssueDetector is already started');
+    }
+
+    this.#running = true;
+  }
+
+  public stopWatchingNewPeerConnections(): void {
+    if (!this.#running) {
+      throw new Error('WebRTCIssueDetector is already stopped');
+    }
+
+    this.#running = false;
+  }
+
+  public resetWatchedPeerConnectionsList(): void {
+    this.webrtcStats.removePeer(this.webrtcStatsPeerId);
+  }
+
+  public handleNewPeerConnection(pc: RTCPeerConnection): void {
+    if (!this.#running) {
+      return;
+    }
+
+    if (!(pc instanceof RTCPeerConnection)) {
+      return;
+    }
+
+    this.webrtcStats.addConnection({
+      pc,
+      peerId: this.webrtcStatsPeerId,
+    });
+  }
+
+  private emitIssues(issues: IssuePayload[]): void {
+    this.eventEmitter.emit(EventType.Issue, issues);
+  }
+
+  private detectIssues(data: WebRTCStatsEventData): void {
+    const issues = this.detectors.reduce((acc, detector) => [
+      ...acc,
+      ...detector.detect(data),
+    ], [] as IssuePayload[]);
+
+    if (issues.length > 0) {
+      this.emitIssues(issues);
+    }
+  }
+}
+
+export default WebRTCIssueDetector;

package/src/engine/wid/WebRTCIssueEmitter.ts

@@ -0,0 +1,9 @@
+import { EventEmitter } from 'events';
+import { EventType, EventPayload, IssueDetectorResult } from './types';
+
+export declare interface WebRTCIssueEmitter {
+  on(event: EventType, listener: (issues: IssueDetectorResult) => void): this;
+  emit(event: EventType, payload: EventPayload): boolean;
+}
+
+export class WebRTCIssueEmitter extends EventEmitter {}

package/src/engine/wid/detectors/AvailableOutgoingBitrateIssueDetector.ts

@@ -0,0 +1,32 @@
+import { WebRTCStatsEventData } from '@peermetrics/webrtc-stats';
+import {
+  IssueDetector,
+  IssueDetectorResult,
+  IssueReason,
+  IssueType,
+} from '../types';
+
+class AvailableOutgoingBitrateIssueDetector implements IssueDetector {
+  #availableOutgoingBitrateTreshhold = 300000; // 300 kbit/s
+
+  detect(data: WebRTCStatsEventData): IssueDetectorResult {
+    const issues: IssueDetectorResult = [];
+    const { availableOutgoingBitrate } = data.connection;
+    if (availableOutgoingBitrate === undefined) {
+      // availableOutgoingBitrate is not measured yet
+      return issues;
+    }
+
+    if (availableOutgoingBitrate < this.#availableOutgoingBitrateTreshhold) {
+      issues.push({
+        type: IssueType.Network,
+        reason: IssueReason.OutboundNetworkThroughput,
+        debug: `availableOutgoingBitrate: ${availableOutgoingBitrate}`,
+      });
+    }
+
+    return issues;
+  }
+}
+
+export default AvailableOutgoingBitrateIssueDetector;

package/src/engine/wid/detectors/FramesDroppedIssueDetector.ts

@@ -0,0 +1,68 @@
+import { WebRTCStatsEventData } from '@peermetrics/webrtc-stats';
+import {
+  IssueDetector,
+  IssueDetectorResult,
+  IssueReason,
+  IssueType,
+} from '../types';
+
+class FramesDroppedIssueDetector implements IssueDetector {
+  #lastProcessedStats: { [connectionId: string]: WebRTCStatsEventData } = {};
+
+  #framesDroppedTreshold = 0.5;
+
+  detect(data: WebRTCStatsEventData): IssueDetectorResult {
+    const issues = this.processData(data);
+    this.#lastProcessedStats[data.connection.id] = data;
+    return issues;
+  }
+
+  private processData(data: WebRTCStatsEventData): IssueDetectorResult {
+    if (!data.video?.inbound) {
+      return [];
+    }
+
+    const streamsWithDroppedFrames = data.video.inbound.filter((stats) => stats.framesDropped > 0);
+    const issues: IssueDetectorResult = [];
+    const previousInboundRTPVideoStreamsStats = this.#lastProcessedStats[data.connection.id]?.video.inbound;
+
+    if (!previousInboundRTPVideoStreamsStats) {
+      return issues;
+    }
+
+    streamsWithDroppedFrames.forEach((streamStats) => {
+      const previousStreamStats = previousInboundRTPVideoStreamsStats.find((item) => item.ssrc === streamStats.ssrc);
+      if (!previousStreamStats) {
+        return;
+      }
+
+      if (streamStats.framesDropped === previousStreamStats.framesDropped) {
+        // stream is decoded correctly
+        return;
+      }
+
+      const deltaFramesReceived = streamStats.framesReceived - previousStreamStats.framesReceived;
+      const deltaFramesDecoded = streamStats.framesDecoded - previousStreamStats.framesDecoded;
+      const deltaFramesDropped = streamStats.framesDropped - previousStreamStats.framesDropped;
+      if (deltaFramesReceived === 0 && deltaFramesDecoded === 0) {
+        // looks like stream is stopped, skip checking framesDropped
+        return;
+      }
+
+      const framesDropped = deltaFramesDropped / deltaFramesReceived;
+      if (framesDropped >= this.#framesDroppedTreshold) {
+        // more than half of the received frames were dropped
+        issues.push({
+          type: IssueType.CPU,
+          reason: IssueReason.DecoderCPUThrottling,
+          ssrc: streamStats.ssrc,
+          debug: `framesDropped: ${Math.round(framesDropped * 100)}`,
+        });
+      }
+    });
+
+    return issues;
+  }
+}
+
+export default FramesDroppedIssueDetector;

package/src/engine/wid/detectors/FramesEncodedSentIssueDetector.ts

@@ -0,0 +1,73 @@
+import { WebRTCStatsEventData } from '@peermetrics/webrtc-stats';
+import {
+  IssueDetector,
+  IssueDetectorResult,
+  IssueReason,
+  IssueType,
+} from '../types';
+
+class FramesEncodedSentIssueDetector implements IssueDetector {
+  #lastProcessedStats: { [connectionId: string]: WebRTCStatsEventData } = {};
+
+  #missedFramesTreshold = 0.15;
+
+  detect(data: WebRTCStatsEventData): IssueDetectorResult {
+    const issues = this.processData(data);
+    this.#lastProcessedStats[data.connection.id] = data;
+    return issues;
+  }
+
+  private processData(data: WebRTCStatsEventData): IssueDetectorResult {
+    if (!data.video?.outbound) {
+      return [];
+    }
+
+    const streamsWithEncodedFrames = data.video.outbound.filter((stats) => stats.framesEncoded > 0);
+    const issues: IssueDetectorResult = [];
+    const previousOutboundRTPVideoStreamsStats = this.#lastProcessedStats[data.connection.id]?.video.outbound;
+
+    if (!previousOutboundRTPVideoStreamsStats) {
+      return issues;
+    }
+
+    streamsWithEncodedFrames.forEach((streamStats) => {
+      const previousStreamStats = previousOutboundRTPVideoStreamsStats.find((item) => item.ssrc === streamStats.ssrc);
+
+      if (!previousStreamStats) {
+        return;
+      }
+
+      if (streamStats.framesEncoded === previousStreamStats.framesEncoded) {
+        // stream is paused
+        return;
+      }
+
+      const deltaFramesEncoded = streamStats.framesEncoded - previousStreamStats.framesEncoded;
+      const deltaFramesSent = streamStats.framesSent - previousStreamStats.framesSent;
+
+      if (deltaFramesEncoded === 0) {
+        // stream is paused
+        return;
+      }
+
+      if (deltaFramesEncoded === deltaFramesSent) {
+        // stream is ok
+        return;
+      }
+
+      const missedFrames = deltaFramesSent / deltaFramesEncoded;
+      if (missedFrames >= this.#missedFramesTreshold) {
+        issues.push({
+          type: IssueType.Network,
+          reason: IssueReason.OutboundNetworkThroughput,
+          ssrc: streamStats.ssrc,
+          debug: `missedFrames: ${Math.round(missedFrames * 100)}%`,
+        });
+      }
+    });
+
+    return issues;
+  }
+}
+
+export default FramesEncodedSentIssueDetector;

package/src/engine/wid/detectors/NetworkIssueDetector.ts

@@ -0,0 +1,95 @@
+import { WebRTCStatsEventData } from '@peermetrics/webrtc-stats';
+import {
+  IssueDetector,
+  IssueDetectorResult,
+  IssueReason,
+  IssueType,
+} from '../types';
+
+class NetworkIssueDetector implements IssueDetector {
+  #lastProcessedStats: { [connectionId: string]: WebRTCStatsEventData } = {};
+
+  detect(data: WebRTCStatsEventData): IssueDetectorResult {
+    const issues = this.processData(data);
+    this.#lastProcessedStats[data.connection.id] = data;
+    return issues;
+  }
+
+  private processData(data: WebRTCStatsEventData): IssueDetectorResult {
+    const issues: IssueDetectorResult = [];
+    const inboundRTPStreamsStats = [...data.audio?.inbound, ...data.video?.inbound];
+    const previousStats = this.#lastProcessedStats[data.connection.id];
+    const previousInboundStreamStats = [...previousStats.video?.inbound, ...previousStats.audio?.inbound];
+
+    if (!inboundRTPStreamsStats.length || !previousStats) {
+      return issues;
+    }
+
+    const { packetsReceived } = data.connection;
+    const lastPacketsReceived = previousStats.connection.packetsReceived;
+
+    const rtpNetworkStats = inboundRTPStreamsStats.reduce((stats, currentStreamStats) => {
+      const previousStreamStats = previousInboundStreamStats.find((stream) => stream.ssrc === currentStreamStats.ssrc);
+      const lastJitterBufferDelay = previousStreamStats?.jitterBufferDelay || 0;
+      const lastJitterBufferEmittedCount = previousStreamStats?.jitterBufferEmittedCount || 0;
+      const delay = currentStreamStats.jitterBufferDelay - lastJitterBufferDelay;
+      const emitted = currentStreamStats.jitterBufferEmittedCount - lastJitterBufferEmittedCount;
+      const latency = delay && emitted ? (1e3 * delay) / emitted : 0;
+
+      return {
+        maxLatency: latency > stats.maxLatency ? latency : stats.maxLatency,
+        packetsLost: stats.packetsLost + currentStreamStats.packetsLost,
+        lastPacketsLost: stats.lastPacketsLost + (previousStreamStats?.packetsLost || 0),
+      };
+    }, { maxLatency: 0, packetsLost: 0, lastPacketsLost: 0 });
+
+    const rtt = (1e3 * data.connection.currentRoundTripTime) || 0;
+    const jitter = Math.round(rtt / 2 + rtpNetworkStats.maxLatency);
+
+    const deltaPacketReceived = packetsReceived - lastPacketsReceived;
+    const deltaPacketLost = rtpNetworkStats.packetsLost - rtpNetworkStats.lastPacketsLost;
+
+    const packetsLoss = deltaPacketReceived && deltaPacketLost
+      ? Math.round((deltaPacketLost * 100) / (deltaPacketReceived + deltaPacketLost))
+      : 0;
+
+    const isHighPacketsLoss = packetsLoss > 5;
+    const isHighJitter = jitter >= 200;
+    const isHighRTT = rtt >= 200;
+
+    const isNetworkIssue = (!isHighPacketsLoss && isHighJitter) || isHighJitter || isHighPacketsLoss;
+    const isServerIssue = isHighRTT && !isHighJitter && !isHighPacketsLoss;
+    const isNetworkMediaLatencyIssue = isHighPacketsLoss && isHighJitter;
+
+    if (isNetworkIssue) {
+      issues.push({
+        type: IssueType.Network,
+        reason: IssueReason.NetworkQuality,
+        iceCandidate: data.connection.local.id,
+        debug: `packetLoss: ${packetsLoss}%, jitter: ${jitter}`,
+      });
+    }
+
+    if (isServerIssue) {
+      issues.push({
+        type: IssueType.Server,
+        reason: IssueReason.ServerIssue,
+        iceCandidate: data.connection.remote.id,
+        debug: `packetLoss: ${packetsLoss}%,jitter: ${jitter}, rtt: ${rtt},`,
+      });
+    }
+
+    if (isNetworkMediaLatencyIssue) {
+      issues.push({
+        type: IssueType.Network,
+        reason: IssueReason.NetworkMediaLatency,
+        iceCandidate: data.connection.local.id,
+        debug: `packetLoss: ${packetsLoss}%, jitter: ${jitter}`,
+      });
+    }
+
+    return issues;
+  }
+}
+
+export default NetworkIssueDetector;

package/src/engine/wid/detectors/NetworkMediaSyncIssueDetector.ts

@@ -0,0 +1,60 @@
+import { WebRTCStatsEventData } from '@peermetrics/webrtc-stats';
+import {
+  IssueDetector,
+  IssueDetectorResult,
+  IssueReason,
+  IssueType,
+} from '../types';
+
+class NetworkMediaSyncIssueDetector implements IssueDetector {
+  #lastProcessedStats: { [connectionId: string]: WebRTCStatsEventData } = {};
+
+  detect(data: WebRTCStatsEventData): IssueDetectorResult {
+    const issues = this.processData(data);
+    this.#lastProcessedStats[data.connection.id] = data;
+    return issues;
+  }
+
+  private processData(data: WebRTCStatsEventData): IssueDetectorResult {
+    const inboundRTPAudioStreamsStats = data.audio.inbound;
+    const issues: IssueDetectorResult = [];
+    const previousInboundRTPAudioStreamsStats = this.#lastProcessedStats[data.connection.id]?.audio.inbound;
+
+    if (!previousInboundRTPAudioStreamsStats) {
+      return issues;
+    }
+
+    inboundRTPAudioStreamsStats.forEach((stats) => {
+      const previousStreamStats = previousInboundRTPAudioStreamsStats.find((item) => item.ssrc === stats.ssrc);
+      if (!previousStreamStats) {
+        return;
+      }
+
+      const nowCorrectedSamples = stats.track.insertedSamplesForDeceleration
+        + stats.track.removedSamplesForAcceleration;
+      const lastCorrectedSamples = previousStreamStats.track.insertedSamplesForDeceleration
+        + previousStreamStats.track.removedSamplesForAcceleration;
+
+      if (nowCorrectedSamples === lastCorrectedSamples) {
+        return;
+      }
+
+      const deltaSamplesReceived = stats.track.totalSamplesReceived - previousStreamStats.track.totalSamplesReceived;
+      const deltaCorrectedSamples = nowCorrectedSamples - lastCorrectedSamples;
+      const correctedSamplesPercentage = Math.round((deltaCorrectedSamples * 100) / deltaSamplesReceived);
+
+      if (correctedSamplesPercentage > 5) {
+        issues.push({
+          type: IssueType.Network,
+          reason: IssueReason.NetworkMediaSyncFailure,
+          ssrc: stats.ssrc,
+          debug: `correctedSamplesPercentage: ${correctedSamplesPercentage}%`,
+        });
+      }
+    });
+
+    return issues;
+  }
+}
+
+export default NetworkMediaSyncIssueDetector;