Adds new parameter details for the connection failed event. (#697)

* Adds new parameter details for the connection failed event.

Adds suspend and shard_changed details.

* Updates the used strophejs version in dependencies.

* Updates the used strophejs version in dependencies (package-lock file).

* Changes to always report suspend time, reports 0 on no suspend detected.

* Updates the used strophejs version in dependencies (1.2.14-1).

* Changes details field name.

JitsiConnection.js

     this.options = options;
     this.xmpp = new XMPP(options, token);
 
+    /* eslint-disable max-params */
     this.addEventListener(JitsiConnectionEvents.CONNECTION_FAILED,
-        (errType, msg) => {
+        (errType, msg, credentials, details) => {
             Statistics.sendAnalyticsAndLog(
-                createConnectionFailedEvent(errType, msg));
+                createConnectionFailedEvent(errType, msg, details));
         });
+    /* eslint-enable max-params */
 
     this.addEventListener(JitsiConnectionEvents.CONNECTION_DISCONNECTED,
         msg => {

JitsiConnectionEvents.js

  * Indicates that the connection has been failed for some reason. The event
  * provides the following parameters to its listeners:
  *
- * @param err {string} the error (message) associated with the failure
+ * @param errType {JitsiConnectionErrors} the type of error associated with
+ * the failure
+ * @param errReason {string} the error (message) associated with the failure
+ * @param credentials {object} the credentials used to connect (if any)
+ * @param errReasonDetails {object} an optional object with details about
+ * the error, like shard moving, suspending. Used for analytics purposes.
  */
 export const CONNECTION_FAILED = 'connection.connectionFailed';
 

modules/xmpp/strophe.ping.js

  */
 const PING_THRESHOLD = 3;
 
+/**
+ * The number of timestamps of send pings to keep.
+ * The current value is 2 minutes.
+ * @type {number} number of timestamps.
+ */
+const PING_TIMESTAMPS_TO_KEEP = 120000 / PING_INTERVAL;
+
 /**
  * XEP-0199 ping plugin.
  *
         super();
         this.failedPings = 0;
         this.xmpp = xmpp;
+        this.pingExecIntervals = new Array(PING_TIMESTAMPS_TO_KEEP);
     }
 
     /**
      * timeout <tt>error<//t> callback is called with undefined error argument.
      */
     ping(jid, success, error, timeout) {
+        this._addPingExecutionTimestamp();
+
         const iq = $iq({
             type: 'get',
             to: jid
             logger.info('Ping interval cleared');
         }
     }
+
+    /**
+     * Adds the current time to the array of send ping timestamps.
+     * @private
+     */
+    _addPingExecutionTimestamp() {
+        this.pingExecIntervals.push(new Date().getTime());
+
+        // keep array length to PING_TIMESTAMPS_TO_KEEP
+        if (this.pingExecIntervals.length > PING_TIMESTAMPS_TO_KEEP) {
+            this.pingExecIntervals.shift();
+        }
+    }
+
+    /**
+     * Returns the maximum time between the recent sent pings, if there is a
+     * big value it means the computer was inactive for some time(suspended).
+     * Checks the maximum gap between sending pings, considering and the
+     * current time. Trying to detect computer inactivity (sleep).
+     *
+     * @returns {int} the time ping was suspended, if it was not 0 is returned.
+     */
+    getPingSuspendTime() {
+        const pingIntervals = this.pingExecIntervals.slice();
+
+        // we need current time, as if ping was sent now
+        // if computer sleeps we will get correct interval after next
+        // scheduled ping, bet we sometimes need that interval before waiting
+        // for the next ping, on closing the connection on error.
+        pingIntervals.push(new Date().getTime());
+
+        let maxInterval = 0;
+        let previousTS = pingIntervals[0];
+
+        pingIntervals.forEach(e => {
+            const currentInterval = e - previousTS;
+
+            if (currentInterval > maxInterval) {
+                maxInterval = currentInterval;
+            }
+
+            previousTS = e;
+        });
+
+        // remove the interval between the ping sent
+        // this way in normal execution there is no suspend and the return
+        // will be 0 or close to 0.
+        maxInterval -= PING_INTERVAL;
+
+        // make sure we do not return less than 0
+        return Math.max(maxInterval, 0);
+    }
 }
 
 /**

modules/xmpp/xmpp.js

             } else if (this.connectionFailed) {
                 this.eventEmitter.emit(
                     JitsiConnectionEvents.CONNECTION_FAILED,
-                    JitsiConnectionErrors.OTHER_ERROR, errMsg);
+                    JitsiConnectionErrors.OTHER_ERROR,
+                    errMsg,
+                    undefined, /* credentials */
+                    this._getConnectionFailedReasonDetails());
             } else if (wasIntentionalDisconnect) {
                 this.eventEmitter.emit(
                     JitsiConnectionEvents.CONNECTION_DISCONNECTED, errMsg);
         initRayo();
         initStropheLogger();
     }
+
+    /**
+     * Returns details about connection failure. Shard change or is it after
+     * suspend.
+     * @returns {object} contains details about a connection failure.
+     * @private
+     */
+    _getConnectionFailedReasonDetails() {
+        const details = {};
+
+        // check for moving between shard if information is available
+        if (this.options.deploymentInfo
+            && this.options.deploymentInfo.shard
+            && this.connection._proto
+            && this.connection._proto.lastResponseHeaders) {
+
+            // split headers by line
+            const headersArr = this.connection._proto.lastResponseHeaders
+                .trim().split(/[\r\n]+/);
+            const headers = {};
+
+            headersArr.forEach(line => {
+                const parts = line.split(': ');
+                const header = parts.shift();
+                const value = parts.join(': ');
+
+                headers[header] = value;
+            });
+
+            /* eslint-disable camelcase */
+            details.shard_changed
+                = this.options.deploymentInfo.shard
+                    !== headers['x-jitsi-shard'];
+            /* eslint-enable camelcase */
+        }
+
+        /* eslint-disable camelcase */
+        // check for possible suspend
+        details.suspend_time = this.connection.ping.getPingSuspendTime();
+        /* eslint-enable camelcase */
+
+        return details;
+    }
 }

package-lock.json

       "dev": true
     },
     "strophe.js": {
-      "version": "1.2.14",
-      "resolved": "https://registry.npmjs.org/strophe.js/-/strophe.js-1.2.14.tgz",
-      "integrity": "sha1-fO7sUbMnLMXGxq53R0eApYQPGqc="
+      "version": "github:jitsi/strophejs#d05254fb28f4bbe6df5f905358582db3a12ee04c"
     },
     "strophejs-plugin-disco": {
       "version": "0.0.2",

package.json

     "sdp-interop": "0.1.12",
     "sdp-simulcast": "0.2.1",
     "sdp-transform": "2.3.0",
-    "strophe.js": "1.2.14",
+    "strophe.js": "github:jitsi/strophejs#1.2.14-1",
     "strophejs-plugin-disco": "0.0.2",
     "webrtc-adapter": "github:webrtc/adapter#1eec19782b4058d186341263e7d049cea3e3290a",
     "yaeti": "1.0.1"

service/statistics/AnalyticsEvents.js

  * Creates an event which indicates that the XMPP connection failed
  * @param errorType TODO
  * @param errorMessage TODO
- */
-export const createConnectionFailedEvent = function(errorType, errorMessage) {
-    return {
-        type: TYPE_OPERATIONAL,
-        action: 'connection.failed',
-        attributes: {
-            'error_type': errorType,
-            'error_message': errorMessage
-        }
+ * @param detail connection failed details.
+ */
+export const createConnectionFailedEvent
+    = function(errorType, errorMessage, details) {
+        return {
+            type: TYPE_OPERATIONAL,
+            action: 'connection.failed',
+            attributes: {
+                'error_type': errorType,
+                'error_message': errorMessage,
+                ...details
+            }
+        };
     };
-};
 
 /**
  * Creates an operational event which indicates that a particular connection