@webex/internal-plugin-mercury 3.0.0-beta.4 → 3.0.0-beta.400

package/src/socket/socket-base.js

@@ -14,7 +14,7 @@ import {
   ConnectionError,
   Forbidden,
   NotAuthorized,
-  UnknownResponse
+  UnknownResponse,
   // NotFound
 } from '../errors';
 
@@ -30,6 +30,7 @@ export default class Socket extends EventEmitter {
    */
   constructor() {
     super();
+    this._domain = 'unknown-domain';
     this.onmessage = this.onmessage.bind(this);
     this.onclose = this.onclose.bind(this);
   }
@@ -88,7 +89,9 @@ export default class Socket extends EventEmitter {
    * @returns {WebSocket}
    */
   static getWebSocketConstructor() {
-    throw new Error('Socket.getWebSocketConstructor() must be implemented in an environmentally appropriate way');
+    throw new Error(
+      'Socket.getWebSocketConstructor() must be implemented in an environmentally appropriate way'
+    );
   }
 
   /**
@@ -109,10 +112,10 @@ export default class Socket extends EventEmitter {
         return;
       }
       // logger is defined once open is called
-      this.logger.info('socket: closing');
+      this.logger.info(`socket,${this._domain}: closing`);
 
       if (socket.readyState === 2 || socket.readyState === 3) {
-        this.logger.info('socket: already closed');
+        this.logger.info(`socket,${this._domain}: already closed`);
         resolve();
 
         return;
@@ -127,24 +130,25 @@ export default class Socket extends EventEmitter {
 
       options = defaults(options, {
         code: 1000,
-        reason: 'Done'
+        reason: 'Done',
       });
 
       const closeTimer = safeSetTimeout(() => {
         try {
-          this.logger.info('socket: no close event received, forcing closure');
-          resolve(this.onclose({
-            code: 1000,
-            reason: 'Done (forced)'
-          }));
-        }
-        catch (error) {
-          this.logger.warn('socket: force-close failed', error);
+          this.logger.info(`socket,${this._domain}: no close event received, forcing closure`);
+          resolve(
+            this.onclose({
+              code: 1000,
+              reason: 'Done (forced)',
+            })
+          );
+        } catch (error) {
+          this.logger.warn(`socket,${this._domain}: force-close failed`, error);
         }
       }, this.forceCloseDelay);
 
       socket.onclose = (event) => {
-        this.logger.info('socket: close event fired', event.code, event.reason);
+        this.logger.info(`socket,${this._domain}: close event fired`, event.code, event.reason);
         clearTimeout(closeTimer);
         this.onclose(event);
         resolve(event);
@@ -168,6 +172,12 @@ export default class Socket extends EventEmitter {
    * @returns {Promise}
    */
   open(url, options) {
+    try {
+      this._domain = new URL(url).hostname;
+    } catch {
+      this._domain = url;
+    }
+
     return new Promise((resolve, reject) => {
       /* eslint complexity: [0] */
       if (!url) {
@@ -184,25 +194,21 @@ export default class Socket extends EventEmitter {
 
       options = options || {};
 
-      checkRequired([
-        'forceCloseDelay',
-        'pingInterval',
-        'pongTimeout',
-        'token',
-        'trackingId',
-        'logger'
-      ], options);
+      checkRequired(
+        ['forceCloseDelay', 'pingInterval', 'pongTimeout', 'token', 'trackingId', 'logger'],
+        options
+      );
 
       Object.keys(options).forEach((key) => {
         Reflect.defineProperty(this, key, {
           enumerable: false,
-          value: options[key]
+          value: options[key],
         });
       });
 
       const WebSocket = Socket.getWebSocketConstructor();
 
-      this.logger.info('socket: creating WebSocket');
+      this.logger.info(`socket,${this._domain}: creating WebSocket`);
       const socket = new WebSocket(url, [], options);
 
       socket.binaryType = 'arraybuffer';
@@ -210,13 +216,13 @@ export default class Socket extends EventEmitter {
 
       socket.onclose = (event) => {
         event = this._fixCloseCode(event);
-        this.logger.info('socket: closed before open', event.code, event.reason);
+        this.logger.info(`socket,${this._domain}: closed before open`, event.code, event.reason);
         switch (event.code) {
           case 1005:
-          // IE 11 doesn't seem to allow 4XXX codes, so if we get a 1005, assume
-          // it's a bad websocket url. That'll trigger a device refresh; if it
-          // turns out we had a bad token, the device refresh should 401 and
-          // trigger a token refresh.
+            // IE 11 doesn't seem to allow 4XXX codes, so if we get a 1005, assume
+            // it's a bad websocket url. That'll trigger a device refresh; if it
+            // turns out we had a bad token, the device refresh should 401 and
+            // trigger a token refresh.
             return reject(new UnknownResponse(event));
           case 4400:
             return reject(new BadRequest(event));
@@ -224,18 +230,18 @@ export default class Socket extends EventEmitter {
             return reject(new NotAuthorized(event));
           case 4403:
             return reject(new Forbidden(event));
-            // case 4404:
-            //   return reject(new NotFound(event));
+          // case 4404:
+          //   return reject(new NotFound(event));
           default:
             return reject(new ConnectionError(event));
         }
       };
 
       socket.onopen = () => {
-        this.logger.info('socket: connected');
+        this.logger.info(`socket,${this._domain}: connected`);
         this._authorize()
           .then(() => {
-            this.logger.info('socket: authorized');
+            this.logger.info(`socket,${this._domain}: authorized`);
             socket.onclose = this.onclose;
             resolve();
           })
@@ -243,11 +249,11 @@ export default class Socket extends EventEmitter {
       };
 
       socket.onerror = (event) => {
-        this.logger.warn('socket: error event fired', event);
+        this.logger.warn(`socket,${this._domain}: error event fired`, event);
       };
 
       sockets.set(this, socket);
-      this.logger.info('socket: waiting for server');
+      this.logger.info(`socket,${this._domain}: waiting for server`);
     });
   }
 
@@ -257,7 +263,7 @@ export default class Socket extends EventEmitter {
    * @returns {undefined}
    */
   onclose(event) {
-    this.logger.info('socket: closed', event.code, event.reason);
+    this.logger.info(`socket,${this._domain}: closed`, event.code, event.reason);
     clearTimeout(this.pongTimer);
     clearTimeout(this.pingTimer);
 
@@ -279,9 +285,11 @@ export default class Socket extends EventEmitter {
       const data = JSON.parse(event.data);
       const sequenceNumber = parseInt(data.sequenceNumber, 10);
 
-      this.logger.debug('socket: sequence number: ', sequenceNumber);
+      this.logger.debug(`socket,${this._domain}: sequence number: `, sequenceNumber);
       if (this.expectedSequenceNumber && sequenceNumber !== this.expectedSequenceNumber) {
-        this.logger.debug(`socket: sequence number mismatch indicates lost mercury message. expected: ${this.expectedSequenceNumber}, actual: ${sequenceNumber}`);
+        this.logger.debug(
+          `socket,${this._domain}: sequence number mismatch indicates lost mercury message. expected: ${this.expectedSequenceNumber}, actual: ${sequenceNumber}`
+        );
         this.emit('sequence-mismatch', sequenceNumber, this.expectedSequenceNumber);
       }
       this.expectedSequenceNumber = sequenceNumber + 1;
@@ -294,17 +302,15 @@ export default class Socket extends EventEmitter {
       this._acknowledge(processedEvent);
       if (data.type === 'pong') {
         this.emit('pong', processedEvent);
-      }
-      else {
+      } else {
         this.emit('message', processedEvent);
       }
-    }
-    catch (error) {
+    } catch (error) {
       // The above code should only be able to throw if we receive an unparsable
       // message from Mercury. At this time, the only action we have is to
       // ignore it and move on.
       /* istanbul ignore next */
-      this.logger.warn('socket: error while receiving WebSocket message', error);
+      this.logger.warn(`socket,${this._domain}: error while receiving WebSocket message`, error);
     }
   }
 
@@ -347,7 +353,7 @@ export default class Socket extends EventEmitter {
 
     return this.send({
       messageId: event.data.id,
-      type: 'ack'
+      type: 'ack',
     });
   }
 
@@ -358,19 +364,23 @@ export default class Socket extends EventEmitter {
    */
   _authorize() {
     return new Promise((resolve) => {
-      this.logger.info('socket: authorizing');
+      this.logger.info(`socket,${this._domain}: authorizing`);
       this.send({
         id: uuid.v4(),
         type: 'authorization',
         data: {
-          token: this.token
+          token: this.token,
         },
         trackingId: this.trackingId,
-        logLevelToken: this.logLevelToken
+        logLevelToken: this.logLevelToken,
       });
 
       const waitForBufferState = (event) => {
-        if (!event.data.type && (event.data.data.eventType === 'mercury.buffer_state' || event.data.data.eventType === 'mercury.registration_status')) {
+        if (
+          !event.data.type &&
+          (event.data.data.eventType === 'mercury.buffer_state' ||
+            event.data.data.eventType === 'mercury.registration_status')
+        ) {
           this.removeListener('message', waitForBufferState);
           this._ping();
           resolve();
@@ -392,12 +402,18 @@ export default class Socket extends EventEmitter {
     if (event.code === 1005 && event.reason) {
       switch (event.reason.toLowerCase()) {
         case 'replaced':
-          this.logger.info('socket: fixing CloseEvent code for reason: ', event.reason);
+          this.logger.info(
+            `socket,${this._domain}: fixing CloseEvent code for reason: `,
+            event.reason
+          );
           event.code = 4000;
           break;
         case 'authentication failed':
         case 'authentication did not happen within the timeout window of 30000 seconds.':
-          this.logger.info('socket: fixing CloseEvent code for reason: ', event.reason);
+          this.logger.info(
+            `socket,${this._domain}: fixing CloseEvent code for reason: `,
+            event.reason
+          );
           event.code = 1008;
           break;
         default:
@@ -417,40 +433,44 @@ export default class Socket extends EventEmitter {
   _ping(id) {
     const confirmPongId = (event) => {
       try {
-        this.logger.debug('socket: pong', event.data.id);
+        this.logger.debug(`socket,${this._domain}: pong`, event.data.id);
         if (event.data && event.data.id !== id) {
-          this.logger.info('socket: received pong for wrong ping id, closing socket');
-          this.logger.debug('socket: expected', id, 'received', event.data.id);
+          this.logger.info(
+            `socket,${this._domain}: received pong for wrong ping id, closing socket`
+          );
+          this.logger.debug(`socket,${this._domain}: expected`, id, 'received', event.data.id);
           this.close({
             code: 1000,
-            reason: 'Pong mismatch'
+            reason: 'Pong mismatch',
           });
         }
-      }
-      catch (error) {
+      } catch (error) {
         // This try/catch block was added as a debugging step; to the best of my
         // knowledge, the above can never throw.
         /* istanbul ignore next */
-        this.logger.error('socket: error occurred in confirmPongId', error);
+        this.logger.error(`socket,${this._domain}: error occurred in confirmPongId`, error);
       }
     };
 
     const onPongNotReceived = () => {
       try {
-        this.logger.info('socket: pong not receive in expected period, closing socket');
+        this.logger.info(
+          `socket,${this._domain}: pong not receive in expected period, closing socket`
+        );
         this.close({
           code: 1000,
-          reason: 'Pong not received'
-        })
-          .catch((reason) => {
-            this.logger.warn('socket: failed to close socket after missed pong', reason);
-          });
-      }
-      catch (error) {
+          reason: 'Pong not received',
+        }).catch((reason) => {
+          this.logger.warn(
+            `socket,${this._domain}: failed to close socket after missed pong`,
+            reason
+          );
+        });
+      } catch (error) {
         // This try/catch block was added as a debugging step; to the best of my
         // knowledge, the above can never throw.
         /* istanbul ignore next */
-        this.logger.error('socket: error occurred in onPongNotReceived', error);
+        this.logger.error(`socket,${this._domain}: error occurred in onPongNotReceived`, error);
       }
     };
 
@@ -458,25 +478,37 @@ export default class Socket extends EventEmitter {
       try {
         clearTimeout(this.pongTimer);
         this.pingTimer = safeSetTimeout(() => this._ping(), this.pingInterval);
-      }
-      catch (error) {
+      } catch (error) {
         // This try/catch block was added as a debugging step; to the best of my
         // knowledge, the above can never throw.
         /* istanbul ignore next */
-        this.logger.error('socket: error occurred in scheduleNextPingAndCancelPongTimer', error);
+        this.logger.error(
+          `socket,${this._domain}: error occurred in scheduleNextPingAndCancelPongTimer`,
+          error
+        );
       }
     };
 
+    const calculateLatency = (pingTimestamp) => {
+      const now = performance.now();
+      const latency = now - pingTimestamp;
+
+      this.logger.debug(`socket,${this._domain}: latency: `, latency);
+      this.emit('ping-pong-latency', latency);
+    };
+
     id = id || uuid.v4();
+    const pingTimestamp = performance.now();
+
     this.pongTimer = safeSetTimeout(onPongNotReceived, this.pongTimeout);
     this.once('pong', scheduleNextPingAndCancelPongTimer);
     this.once('pong', confirmPongId);
-
-    this.logger.debug(`socket: ping ${id}`);
+    this.once('pong', () => calculateLatency(pingTimestamp));
+    this.logger.debug(`socket,${this._domain}: ping ${id}`);
 
     return this.send({
       id,
-      type: 'ping'
+      type: 'ping',
     });
   }
 }

package/src/socket/socket.shim.js

@@ -1,3 +1,5 @@
+/* eslint-disable no-restricted-globals */
+
 /*!
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
@@ -12,18 +14,14 @@ Socket.getWebSocketConstructor = function getWebSocketConstructor() {
 
   if (typeof WebSocket !== 'undefined') {
     ws = WebSocket;
-  }
-  else if (typeof MozWebSocket !== 'undefined') {
+  } else if (typeof MozWebSocket !== 'undefined') {
     // eslint-disable-next-line no-undef
     ws = MozWebSocket;
-  }
-  else if (typeof global !== 'undefined') {
+  } else if (typeof global !== 'undefined') {
     ws = global.WebSocket || global.MozWebSocket;
-  }
-  else if (typeof window !== 'undefined') {
+  } else if (typeof window !== 'undefined') {
     ws = window.WebSocket || window.MozWebSocket;
-  }
-  else if (typeof self !== 'undefined') {
+  } else if (typeof self !== 'undefined') {
     ws = self.WebSocket || self.MozWebSocket;
   }
 

package/test/integration/spec/mercury.js

@@ -16,34 +16,37 @@ describe('plugin-mercury', function () {
   describe('Mercury', () => {
     let webex;
 
-    beforeEach(() => testUsers.create({count: 1})
-      .then((users) => {
+    beforeEach(() =>
+      testUsers.create({count: 1}).then((users) => {
         webex = new WebexCore({
           credentials: {
-            supertoken: users[0].token
+            supertoken: users[0].token,
           },
           config: {
             credentials: {
-              refreshCallback
-            }
-          }
+              refreshCallback,
+            },
+          },
         });
-      }));
+      })
+    );
 
     afterEach(() => webex && webex.internal.mercury.disconnect());
 
     describe('#connect()', () => {
       it('connects to mercury', () => webex.internal.mercury.connect());
 
-      it('refreshes the access token when a 4401 is received', () => webex.internal.device.register()
-        .then(() => {
-          // eslint-disable-next-line camelcase
-          webex.credentials.supertoken.access_token = 'fake token';
+      it('refreshes the access token when a 4401 is received', () =>
+        webex.internal.device
+          .register()
+          .then(() => {
+            // eslint-disable-next-line camelcase
+            webex.credentials.supertoken.access_token = 'fake token';
 
-          return webex.internal.mercury.connect();
-        })
-        // eslint-disable-next-line camelcase
-        .then(() => assert.notEqual(webex.credentials.supertoken.access_token, 'fake token')));
+            return webex.internal.mercury.connect();
+          })
+          // eslint-disable-next-line camelcase
+          .then(() => assert.notEqual(webex.credentials.supertoken.access_token, 'fake token')));
 
       // This doesn't work as designed yet. The only way to get a 4404 is to try
       // to connect to someone else's valid registration; the intent was to get
@@ -70,26 +73,34 @@ describe('plugin-mercury', function () {
       });
 
       describe('when web-high-availability is enabled', () => {
-        flaky(it, process.env.SKIP_FLAKY_TESTS)('connects to mercury using service catalog url', () => {
-          let defaultWebSocketUrl;
-
-          // we need to ensure the feature is set for user before "registering"
-          // the device
-          return webex.internal.device.register()
-            .then(() => webex.internal.feature.setFeature('developer', 'web-high-availability', true))
-            .then(() => webex.internal.device.unregister())
-            // start the test flow the device list
-            .then(() => webex.internal.device.register())
-            .then(() => {
-              defaultWebSocketUrl = webex.internal.device.webSocketUrl;
-            })
-            .then(() => webex.internal.mercury.connect())
-            .then(() => webex.internal.device.getWebSocketUrl())
-            .then((wsUrl) => {
-              assert.notEqual(defaultWebSocketUrl, webex.internal.mercury.socket.url);
-              assert.include(webex.internal.mercury.socket.url, wsUrl);
-            });
-        });
+        flaky(it, process.env.SKIP_FLAKY_TESTS)(
+          'connects to mercury using service catalog url',
+          () => {
+            let defaultWebSocketUrl;
+
+            // we need to ensure the feature is set for user before "registering"
+            // the device
+            return (
+              webex.internal.device
+                .register()
+                .then(() =>
+                  webex.internal.feature.setFeature('developer', 'web-high-availability', true)
+                )
+                .then(() => webex.internal.device.unregister())
+                // start the test flow the device list
+                .then(() => webex.internal.device.register())
+                .then(() => {
+                  defaultWebSocketUrl = webex.internal.device.webSocketUrl;
+                })
+                .then(() => webex.internal.mercury.connect())
+                .then(() => webex.internal.device.getWebSocketUrl())
+                .then((wsUrl) => {
+                  assert.notEqual(defaultWebSocketUrl, webex.internal.mercury.socket.url);
+                  assert.include(webex.internal.mercury.socket.url, wsUrl);
+                })
+            );
+          }
+        );
       });
     });
 
@@ -98,10 +109,9 @@ describe('plugin-mercury', function () {
 
       webex.internal.mercury.on('event:mercury.buffer_state', spy);
 
-      return webex.internal.mercury.connect()
-        .then(() => {
-          assert.calledOnce(spy);
-        });
+      return webex.internal.mercury.connect().then(() => {
+        assert.calledOnce(spy);
+      });
     });
   });
 });

package/test/integration/spec/sharable-mercury.js

@@ -14,17 +14,19 @@ describe('plugin-mercury', function () {
   describe('Sharable Mercury', () => {
     let webex;
 
-    beforeEach(() => testUsers.create({count: 1})
-      .then((users) => {
+    beforeEach(() =>
+      testUsers.create({count: 1}).then((users) => {
         webex = new WebexCore({
           credentials: {
-            supertoken: users[0].token
-          }
+            supertoken: users[0].token,
+          },
         });
 
-        return webex.internal.device.register()
+        return webex.internal.device
+          .register()
           .then(() => webex.internal.feature.setFeature('developer', 'web-shared-mercury', true));
-      }));
+      })
+    );
 
     afterEach(() => webex && webex.internal.mercury.disconnect());
 
@@ -39,17 +41,19 @@ describe('plugin-mercury', function () {
       webex.internal.mercury.on('event:mercury.buffer_state', spy1);
       webex.internal.mercury.on('event:mercury.registration_status', spy2);
 
-      return webex.internal.mercury.connect()
-        .then(() => {
-          assert.notCalled(spy1);
-          assert.calledOnce(spy2);
-          const {data} = spy2.args[0][0];
+      return webex.internal.mercury.connect().then(() => {
+        assert.notCalled(spy1);
+        assert.calledOnce(spy2);
+        const {data} = spy2.args[0][0];
 
-          assert.property(data, 'bufferState');
-          assert.property(data, 'localClusterServiceUrls');
+        assert.property(data, 'bufferState');
+        assert.property(data, 'localClusterServiceUrls');
 
-          assert.deepEqual(webex.internal.mercury.localClusterServiceUrls, data.localClusterServiceUrls);
-        });
+        assert.deepEqual(
+          webex.internal.mercury.localClusterServiceUrls,
+          data.localClusterServiceUrls
+        );
+      });
     });
   });
 });

package/test/integration/spec/webex.js

@@ -14,29 +14,31 @@ describe('plugin-mercury', function () {
 
   let webex;
 
-  beforeEach('create users', () => testUsers.create({count: 1})
-    .then(async (users) => {
+  beforeEach('create users', () =>
+    testUsers.create({count: 1}).then(async (users) => {
       // Pause for 5 seconds for CI
       await new Promise((done) => setTimeout(done, 5000));
 
       webex = new WebexCore({
         credentials: {
-          supertoken: users[0].token
-        }
+          supertoken: users[0].token,
+        },
       });
       sinon.spy(webex.internal.mercury, 'disconnect');
       sinon.spy(webex.internal.device, 'unregister');
 
       return webex.internal.mercury.connect();
-    }));
+    })
+  );
 
   describe('onBeforeLogout()', () => {
-    it('disconnects the web socket', () => webex.logout({noRedirect: true})
-      .then(() => {
+    it('disconnects the web socket', () => {
+      webex.logout({noRedirect: true}).then(() => {
         assert.called(webex.internal.mercury.disconnect);
         assert.isFalse(webex.internal.mercury.connected);
         assert.called(webex.internal.device.unregister);
         assert.isFalse(webex.internal.device.registered);
-      }));
+      });
+    });
   });
 });