@flashphoner/websdk 2.0.260 → 2.0.261

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flashphoner/websdk",
-  "version": "2.0.260",
+  "version": "2.0.261",
   "description": "Official Flashphoner WebCallServer WebSDK package",
   "main": "./src/flashphoner-core.js",
   "types": "./src/flashphoner-core.d.ts",

package/src/constants.d.ts

@@ -645,6 +645,12 @@ export const ERROR_INFO: Readonly<{
      * @memberOf Flashphoner.constants.ERROR_INFO
      */
     CAN_NOT_SET_RESOLUTION: string;
+    /**
+     * Error if cannot get peer connection stats
+     * @event CAN_NOT_GET_STATS
+     * @memberOf Flashphoner.constants.ERROR_INFO
+     */
+    CAN_NOT_GET_STATS: string;
     /**
      * Local browser error detected
      * @event LOCAL_ERROR

package/src/constants.js

@@ -654,6 +654,12 @@ const ERROR_INFO = Object.freeze({
      * @memberOf Flashphoner.constants.ERROR_INFO
      */
     CAN_NOT_SET_RESOLUTION: 'Cannot switch a published stream resolution',
+    /**
+     * Error if cannot get peer connection stats
+     * @event CAN_NOT_GET_STATS
+     * @memberOf Flashphoner.constants.ERROR_INFO
+     */
+    CAN_NOT_GET_STATS: 'Cannot get PeerConnection stats',
     /**
      * Local browser error detected
      * @event LOCAL_ERROR

package/src/flashphoner-core.js

@@ -5,6 +5,7 @@ const constants = require("./constants");
 const util = require('./util');
 const LoggerObject = require('./util').logger;
 const clientInfo = require('./client-info');
+const StatsCollector = require('./stats-collector');
 const Promise = require('promise-polyfill');
 const KalmanFilter = require('kalmanjs');
 const browserDetails = require('webrtc-adapter').default.browserDetails;
@@ -519,6 +520,9 @@ var createSession = function (options) {
 
     var wsConnection;
 
+    // WebRTC metrics sending description
+    let webRTCMetricsServerDescription;
+
     if (lbUrl) {
         requestURL(lbUrl);
     } else {
@@ -621,6 +625,7 @@ var createSession = function (options) {
                 case 'getUserData':
                     authToken = obj.authToken;
                     cConfig = obj;
+                    webRTCMetricsServerDescription = obj.webRTCMetricsServerDescription;
                     onSessionStatusChange(SESSION_STATUS.ESTABLISHED, obj);
                     break;
                 case 'setRemoteSDP':
@@ -725,6 +730,34 @@ var createSession = function (options) {
                         streamRefreshHandlers[obj.mediaSessionId](obj);
                     }
                     break;
+                case `webRTCMetricsDescriptionUpdate`:
+                    if (obj.ids) {
+                        obj.ids.forEach((id) => {
+                            if (streamRefreshHandlers[id]) {
+                                streamRefreshHandlers[id](obj);
+                            }
+                        });
+                    } else {
+                        if (obj.compression) {
+                            webRTCMetricsServerDescription.compression = obj.compression;
+                        }
+                        if (obj.batchSize) {
+                            webRTCMetricsServerDescription.batchSize = obj.batchSize;
+                        }
+                        if (obj.sampling) {
+                            webRTCMetricsServerDescription.sampling = obj.sampling;
+                        }
+                        if (obj.types) {
+                            webRTCMetricsServerDescription.types = obj.types;
+                        }
+                        if (obj.collect) {
+                            webRTCMetricsServerDescription.collect = obj.collect;
+                        }
+                        for (const [id, handler] of Object.entries(streamRefreshHandlers)) {
+                            handler(obj);
+                        }
+                    }
+                    break;
                 default:
                     logger.info(LOG_PREFIX, "Unknown server message " + data.message);
             }
@@ -736,10 +769,12 @@ var createSession = function (options) {
 
     //WebSocket send helper
     function send(message, data) {
-        wsConnection.send(JSON.stringify({
-            message: message,
-            data: [data]
-        }));
+        if (wsConnection.readyState === WebSocket.OPEN) {
+            wsConnection.send(JSON.stringify({
+                message: message,
+                data: [data]
+            }));
+        }
     }
 
     //Session status update helper
@@ -1773,6 +1808,8 @@ var createSession = function (options) {
 
         var videoBytes = 0;
 
+        var statsCollector = null;
+
         /**
          * Represents media stream.
          *
@@ -1807,7 +1844,7 @@ var createSession = function (options) {
                 return;
             }
 
-            if (streamInfo.available != undefined) {
+            if (streamInfo.available !== undefined) {
                 for (var i = 0; i < availableCallbacks.length; i++) {
                     info_ = streamInfo.reason;
                     if (streamInfo.available == "true") {
@@ -1866,10 +1903,28 @@ var createSession = function (options) {
                 if (mediaConnection) {
                     mediaConnection.close(cacheLocalResources);
                 }
+                if (statsCollector) {
+                    statsCollector.stop();
+                    statsCollector = null;
+                }
             }
             if (record_ && typeof streamInfo.recordName !== 'undefined') {
                 recordFileName = streamInfo.recordName;
             }
+
+            // Set up metrics collection
+            if (event === STREAM_STATUS.PUBLISHING || event === STREAM_STATUS.PLAYING) {
+                if (webRTCMetricsServerDescription && !statsCollector) {
+                    statsCollector = StatsCollector.StreamStatsCollector(webRTCMetricsServerDescription, id_, mediaConnection, wsConnection, logger);
+                    statsCollector.start();
+                }
+            }
+
+            // Pause or resume metrics collection
+            if (!streamInfo.status && streamInfo.collect !== undefined && statsCollector) {
+                statsCollector.update(streamInfo);
+            }
+
             //fire stream event
             if (callbacks[event]) {
                 callbacks[event](stream);

package/src/stats-collector.js

@@ -0,0 +1,318 @@
+'use strict';
+
+const util = require('./util');
+const LOG_PREFIX = "stats-collector";
+
+// Collect and send WebRTC statistics periodically
+const StreamStatsCollector = function(description, id, mediaConnection, wsConnection, logger) {
+    let statCollector = {
+        description: description,
+        id: id,
+        mediaConnection: mediaConnection,
+        wsConnection: wsConnection,
+        logger: getLogger(logger),
+        headers: "",
+        compression: "none",
+        metricsBatch: null,
+        timer: null,
+        batchCount: 0,
+        start: async function() {
+            let error = "Can't collect WebRTC stats to send: ";
+            if (!statCollector.description.types) {
+                throw new Error(error + "no report types defined");
+            }
+            if (!statCollector.description.sampling) {
+                throw new Error(error + "no sampling interval defined");
+            }
+            if (!statCollector.description.batchSize) {
+                throw new Error(error + "no metrics batch size defined");
+            }
+            if (!statCollector.mediaConnection) {
+                throw new Error(error + "no media connection available");
+            }
+            if (!statCollector.wsConnection) {
+                throw new Error(error + "no websocket connection available");
+            }
+
+            await statCollector.updateHeaders();
+            await statCollector.updateCompression();
+            statCollector.sendHeaders();
+            if (statCollector.description.collect === "on") {
+                statCollector.collect(true);
+            }
+        },
+        collect: function(enable) {
+            if (enable) {
+                statCollector.startTimer();
+            } else {
+                statCollector.stopTimer();
+            }
+        },
+        stop: function() {
+            statCollector.stopTimer();
+            statCollector.headers = "";
+        },
+        update: async function(description) {
+            if (!description) {
+                if (statCollector.logger) {
+                    statCollector.logger.error(LOG_PREFIX, "Can't update WebRTC metrics sending: no parameters passed");
+                    return;
+                }
+            }
+            if (description.types || description.compression) {
+                statCollector.stop();
+                if (description.types) {
+                    statCollector.description.types = description.types;
+                    await statCollector.updateHeaders();
+                }
+                if (description.compression) {
+                    statCollector.description.compression = description.compression;
+                    await statCollector.updateCompression();
+                }
+                statCollector.sendHeaders();
+            } else {
+                statCollector.collect(false);
+            }
+            if (description.batchSize) {
+                statCollector.description.batchSize = description.batchSize;
+            }
+            if (description.sampling) {
+                statCollector.description.sampling = description.sampling;
+            }
+            if (description.collect) {
+                statCollector.description.collect = description.collect;
+            }
+            switch(statCollector.description.collect) {
+                case "on":
+                    statCollector.collect(true);
+                    break;
+                case "off":
+                    statCollector.collect(false);
+                    break;
+            }
+        },
+        updateHeaders: async function() {
+            let stats = await statCollector.mediaConnection.getWebRTCStats();
+            Object.keys(statCollector.description.types).forEach((type) => {
+                let typeDescriptor = statCollector.description.types[type];
+                let metricsString = "";
+                let contentFilters = null;
+                if (typeDescriptor.metrics) {
+                    metricsString = typeDescriptor.metrics;
+                }
+                if (typeDescriptor.contains) {
+                    contentFilters = typeDescriptor.contains;
+                }
+                if (stats[type]) {
+                    stats[type].forEach((report) => {
+                        statCollector.logger.debug(LOG_PREFIX, type + " report: " + JSON.stringify(report));
+                        if (contentFilters) {
+                            let filtersMatched = true;
+                            for (const filter in contentFilters) {
+                                statCollector.logger.debug(LOG_PREFIX, type + " filter by " + filter + ": " + JSON.stringify(contentFilters[filter]));
+                                let filterMatched = false;
+                                if (report[filter]) {
+                                    for (const value of contentFilters[filter]) {
+                                        statCollector.logger.debug(LOG_PREFIX, filter + ": " + value + " <>  " + report[filter]);
+                                        if (report[filter] === value) {
+                                            filterMatched = true;
+                                            break;
+                                        }
+                                    }
+                                }
+                                filtersMatched = filtersMatched && filterMatched;
+                                if (!filterMatched) {
+                                    break;
+                                }
+                            }
+                            if (filtersMatched) {
+                                statCollector.addHeaders(report, metricsString);
+                            }
+                        } else {
+                            statCollector.addHeaders(report, metricsString);
+                        }
+                    });
+                } else {
+                    statCollector.logger.warn(LOG_PREFIX, "No report type found in RTC stats: '" + type + "'");
+                }
+            });
+        },
+        addHeaders: function(report, metricsString) {
+            if (metricsString) {
+                let metrics = metricsString.split(",");
+                metrics.forEach((metric) => {
+                    let metricFound = false;
+                    for (const key of Object.keys(report)) {
+                        if (metric === key) {
+                            statCollector.headers = util.addFieldToCsvString(statCollector.headers, report.type + "." + report.id + "." + metric, ",");
+                            metricFound = true;
+                            break;
+                        }
+                    }
+                    if (!metricFound) {
+                        statCollector.logger.warn(LOG_PREFIX, "No metric found in RTC stats report '" + report.type + "': '" + metric + "'");
+                    }
+                });
+            }
+        },
+        updateCompression: async function() {
+            if (statCollector.description.compression) {
+                if (statCollector.description.compression.indexOf("gzip") >= 0) {
+                    await statCollector.checkForCompression("gzip");
+                } else if (statCollector.description.compression.indexOf("deflate") >= 0) {
+                    await statCollector.checkForCompression("deflate");
+                }
+            }
+        },
+        checkForCompression: async function(compression) {
+            try {
+                await util.compress(compression, "test", false);
+                statCollector.compression = compression;
+            } catch (e) {
+                statCollector.logger.warn(LOG_PREFIX, "Can't compress metrics data using " + compression + ": " + e);
+                statCollector.compression = "none";
+            }
+        },
+        sendHeaders: function() {
+            let data = {
+                mediaSessionId: statCollector.id,
+                compression: statCollector.compression,
+                headers: statCollector.headers
+            };
+            statCollector.send("webRTCMetricsClientDescription", data);
+        },
+        send: function(message, data) {
+            statCollector.logger.debug(LOG_PREFIX, data);
+            if (statCollector.wsConnection.readyState === WebSocket.OPEN) {
+                statCollector.wsConnection.send(JSON.stringify({
+                    message: message,
+                    data: [data]
+                }));
+            }
+        },
+        startTimer: function() {
+            if (!statCollector.timer && statCollector.headers) {
+                statCollector.batchCount = statCollector.description.batchSize;
+                statCollector.timer = setInterval(statCollector.collectMetrics, statCollector.description.sampling);
+            }
+        },
+        stopTimer: function() {
+            if (statCollector.timer) {
+                clearInterval(statCollector.timer);
+                statCollector.timer = null;
+                statCollector.metricsBatch = null;
+            }
+        },
+        collectMetrics: async function() {
+            if (statCollector.timer) {
+                let stats = await statCollector.mediaConnection.getWebRTCStats();
+
+                if (!statCollector.metricsBatch) {
+                    statCollector.metricsBatch = [];
+                }
+
+                let metrics = [];
+                statCollector.headers.split(",").forEach((header) => {
+                    let components = header.split(".");
+                    let descriptor = {
+                        type: components[0],
+                        id: components[1],
+                        name: components[2]
+                    }
+                    let value = "undefined";
+
+                    if (stats[descriptor.type]) {
+                        for (const report of stats[descriptor.type]) {
+                            if (report.id === descriptor.id) {
+                                value = report[descriptor.name];
+                                break;
+                            }
+                        }
+                    }
+                    metrics.push(value);
+                });
+                statCollector.metricsBatch.push(metrics);
+                statCollector.batchCount--;
+                if (statCollector.batchCount === 0) {
+                    await statCollector.sendMetrics();
+                }
+            }
+        },
+        sendMetrics: async function() {
+            let previous;
+            let metricsToSend = [];
+            let metricsData;
+
+            for (let i = 0; i < statCollector.metricsBatch.length; i++) {
+                let metricsString = "";
+                for (let j = 0; j < statCollector.metricsBatch[i].length; j++) {
+                    let valueString = valueToString(statCollector.metricsBatch[i][j]);
+                    let previousString = "";
+                    let separator = ";";
+                    if (previous) {
+                        previousString = valueToString(previous[j]);
+                    }
+                    if (valueString === previousString) {
+                        valueString = "";
+                    }
+                    metricsString = util.addFieldToCsvString(metricsString, valueString, separator);
+                }
+                previous = statCollector.metricsBatch[i];
+                metricsToSend.push(metricsString);
+            }
+            if (statCollector.compression !== "none") {
+                try {
+                    metricsData = await util.compress(statCollector.compression, JSON.stringify(metricsToSend), true);
+                } catch(e) {
+                    statCollector.logger.warn(LOG_PREFIX, "Can't send metrics data using" + statCollector.compression + ": " + e);
+                    metricsData = null;
+                }
+            } else {
+                metricsData = metricsToSend;
+            }
+            if (metricsData) {
+                let data = {
+                    mediaSessionId: statCollector.id,
+                    metrics: metricsData
+                };
+                statCollector.send("webRTCMetricsBatch", data);
+            }
+            statCollector.metricsBatch = null;
+            statCollector.batchCount = statCollector.description.batchSize;
+        }
+    }
+    return statCollector;
+}
+
+// Helper function to stringify a value
+const valueToString = function(value) {
+    let valueString = "undefined";
+    if (typeof value === "object") {
+        valueString = JSON.stringify(value);
+    } else {
+        valueString = value.toString();
+    }
+    return valueString;
+}
+
+// Helper function to get logger object
+const getLogger = function(logger) {
+    if (logger) {
+        if (logger.info !== undefined &&
+            logger.warn !== undefined &&
+            logger.error !== undefined &&
+            logger.debug !== undefined) {
+            return logger;
+        }
+    }
+    return {
+        info: function() {},
+        warn: function() {},
+        error: function() {},
+        debug: function() {}
+    };
+}
+
+module.exports = {
+    StreamStatsCollector: StreamStatsCollector
+}

package/src/util.js

@@ -490,6 +490,64 @@ const setPublishingBitrate = function(sdp, mediaConnection, minBitrate, maxBitra
     return sdp;
 };
 
+const addFieldToCsvString = function(csvString, field, separator) {
+    if (field !== "" && field.indexOf(separator) >= 0 ) {
+        field = '"' + field + '"';
+    }
+    if (csvString === "" && field !== "") {
+        csvString = field;
+    } else {
+        csvString = csvString + separator + field;
+    }
+    return csvString;
+}
+
+const compress = async function(compression, data, base64) {
+    // Throw exception if CompessionStream is not available
+    if (typeof CompressionStream === "undefined") {
+        throw new Error("Compression is not available");
+    }
+
+    // Convert incoming string to a stream
+    let stream;
+    if(typeof data == "string") {
+        stream = new Blob([data], {
+            type: 'text/plain',
+        }).stream();
+    } else {
+        // Assume blog
+        stream = data.stream();
+    }
+
+    // gzip stream
+    const compressedReadableStream = stream.pipeThrough(
+        new CompressionStream(compression)
+    );
+
+    // create Response
+    const compressedResponse = await new Response(compressedReadableStream);
+
+    // Get response Blob
+    const blob = await compressedResponse.blob();
+
+    if(base64) {
+        // Get the ArrayBuffer
+        const buffer = await blob.arrayBuffer();
+
+        // convert ArrayBuffer to base64 encoded string
+        const compressedBase64 = btoa(
+            String.fromCharCode(
+                ...new Uint8Array(buffer)
+            )
+        );
+
+        return compressedBase64;
+
+    } else {
+        return blob;
+    }
+}
+
 module.exports = {
     isEmptyObject,
     copyObjectToArray,
@@ -501,5 +559,7 @@ module.exports = {
     stripCodecs,
     getCurrentCodecAndSampleRate,
     isPromise,
-    setPublishingBitrate
+    setPublishingBitrate,
+    addFieldToCsvString,
+    compress
 };