Passes the info about stream renderer element id to CallStats.

JitsiConference.js

                 conference.statistics.sendSetupFailedEvent();
             });
 
+        conference.rtc.addListener(RTCEvents.TRACK_ATTACHED,
+            function(track, container) {
+                var ssrc = track.getSSRC();
+                if (!container.id || !ssrc) {
+                    return;
+                }
+                conference.statistics.associateStreamWithVideoTag(
+                    ssrc, track.isLocal(), track.getUsageLabel(), container.id);
+
+            });
+
         conference.on(JitsiConferenceEvents.TRACK_MUTE_CHANGED,
             function (track) {
                 if(!track.isLocal())

modules/RTC/JitsiLocalTrack.js

     this.rtc = rtc;
 };
 
+/**
+ * Gets the SSRC of this local track if it's available already or <tt>null</tt>
+ * otherwise. That's because we don't know the SSRC until local description is
+ * created.
+ * @returns {string} or {null}
+ */
+JitsiLocalTrack.prototype.getSSRC = function () {
+    if (!this.rtc.room.session)
+        return null;
+    if (this.isAudioTrack()) {
+        return this.rtc.room.session.localStreamsSSRC.audio;
+    } else {
+        return this.rtc.room.session.localStreamsSSRC.video;
+    }
+};
+
 /**
  * Return true;
  */

modules/RTC/JitsiTrack.js

 var logger = require("jitsi-meet-logger").getLogger(__filename);
 var RTCBrowserType = require("./RTCBrowserType");
+var RTCEvents = require("../../service/RTC/RTCEvents");
 var JitsiTrackEvents = require("../../JitsiTrackEvents");
 var EventEmitter = require("events");
 var RTC = require("./RTCUtils");
     return this.stream;
 }
 
+/**
+ * Return meaningful usage label for this track depending on it's media and
+ * eventual video type.
+ * @returns {string}
+ */
+JitsiTrack.prototype.getUsageLabel = function () {
+    if (this.type == JitsiTrack.AUDIO) {
+        return "mic";
+    } else {
+        return this.videoType ? this.videoType : "default";
+    }
+};
+
 /**
  * Mutes the track.
  */
             = require("./RTCUtils").attachMediaStream(container, this.stream);
     }
     this.containers.push(container);
+
+    this.rtc.eventEmitter.emit(RTCEvents.TRACK_ATTACHED, this, container);
+
     return container;
 }
 

modules/statistics/CallStats.js

     logger.log("Monitoring status: "+ err + " msg: " + msg);
 });
 
+/**
+ * Lets CallStats module know where is given SSRC rendered by providing renderer
+ * tag ID.
+ * @param ssrc {number} the SSRC of the stream
+ * @param isLocal {boolean} <tt>true<tt> if this stream is local or
+ *        <tt>false</tt> otherwise.
+ * @param usageLabel {string} meaningful usage label of this stream like
+ *        'microphone', 'camera' or 'screen'.
+ * @param containerId {string} the id of media 'audio' or 'video' tag which
+ *        renders the stream.
+ */
+CallStats.prototype.associateStreamWithVideoTag =
+function (ssrc, isLocal, usageLabel, containerId) {
+    if(!callStats) {
+        return;
+    }
+    // 'focus' is default remote user ID for now
+    var callStatsId = 'focus';
+    if (isLocal) {
+        callStatsId = this.userID;
+    }
+
+    _try_catch(function() {
+        logger.debug(
+            "Calling callStats.associateMstWithUserID with:",
+            this.peerconnection,
+            callStatsId,
+            this.confID,
+            ssrc,
+            usageLabel,
+            containerId
+        );
+        callStats.associateMstWithUserID(
+            this.peerconnection,
+            callStatsId,
+            this.confID,
+            ssrc,
+            usageLabel,
+            containerId
+        );
+    }).bind(this)();
+};
+
 /**
  * Notifies CallStats for mute events
  * @param mute {boolean} true for muted and false for not muted

modules/statistics/statistics.js

         CallStats.sendMuteEvent(muted, type, this.callstats);
 };
 
+/**
+ * Lets the underlying statistics module know where is given SSRC rendered by
+ * providing renderer tag ID.
+ * @param ssrc {number} the SSRC of the stream
+ * @param isLocal {boolean} <tt>true<tt> if this stream is local or
+ *        <tt>false</tt> otherwise.
+ * @param usageLabel {string} meaningful usage label of this stream like
+ *        'microphone', 'camera' or 'screen'.
+ * @param containerId {string} the id of media 'audio' or 'video' tag which
+ *        renders the stream.
+ */
+Statistics.prototype.associateStreamWithVideoTag =
+function (ssrc, isLocal, usageLabel, containerId) {
+    if(this.callStatsIntegrationEnabled && this.callstats) {
+        this.callstats.associateStreamWithVideoTag(
+            ssrc, isLocal, usageLabel, containerId);
+    }
+};
+
 /**
  * Notifies CallStats that getUserMedia failed.
  *

service/RTC/RTCEvents.js

     DOMINANTSPEAKER_CHANGED: "rtc.dominantspeaker_changed",
     LASTN_ENDPOINT_CHANGED: "rtc.lastn_endpoint_changed",
     AVAILABLE_DEVICES_CHANGED: "rtc.available_devices_changed",
-    FAKE_VIDEO_TRACK_CREATED: "rtc.fake_video_track_created"
+    FAKE_VIDEO_TRACK_CREATED: "rtc.fake_video_track_created",
+    TRACK_ATTACHED: "rtc.track_attached"
 };
 
 module.exports = RTCEvents;