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

package/src/mercury.js

@@ -15,16 +15,11 @@ import {
   Forbidden,
   NotAuthorized,
   UnknownResponse,
-  ConnectionError
+  ConnectionError,
   // NotFound
 } from './errors';
 
-const normalReconnectReasons = [
-  'idle',
-  'done (forced)',
-  'pong not received',
-  'pong mismatch'
-];
+const normalReconnectReasons = ['idle', 'done (forced)', 'pong not received', 'pong mismatch'];
 
 const Mercury = WebexPlugin.extend({
   namespace: 'Mercury',
@@ -32,14 +27,18 @@ const Mercury = WebexPlugin.extend({
   session: {
     connected: {
       default: false,
-      type: 'boolean'
+      type: 'boolean',
     },
     connecting: {
       default: false,
-      type: 'boolean'
+      type: 'boolean',
+    },
+    hasEverConnected: {
+      default: false,
+      type: 'boolean',
     },
     socket: 'object',
-    localClusterServiceUrls: 'object'
+    localClusterServiceUrls: 'object',
   },
 
   derived: {
@@ -47,42 +46,41 @@ const Mercury = WebexPlugin.extend({
       deps: ['connected'],
       fn() {
         return this.connected;
-      }
-    }
+      },
+    },
   },
 
   @oneFlight
   connect(webSocketUrl) {
     if (this.connected) {
-      this.logger.info('mercury: already connected, will not connect again');
+      this.logger.info(`${this.namespace}: already connected, will not connect again`);
 
       return Promise.resolve();
     }
 
     this.connecting = true;
 
-    return Promise.resolve(this.webex.internal.device.registered || this.webex.internal.device.register())
-      .then(() => {
-        this.logger.info('mercury: connecting');
+    return Promise.resolve(
+      this.webex.internal.device.registered || this.webex.internal.device.register()
+    ).then(() => {
+      this.logger.info(`${this.namespace}: connecting`);
 
-        return this._connectWithBackoff(webSocketUrl);
-      });
+      return this._connectWithBackoff(webSocketUrl);
+    });
   },
 
   @oneFlight
   disconnect() {
     return new Promise((resolve) => {
       if (this.backoffCall) {
-        this.logger.info('mercury: aborting connection');
+        this.logger.info(`${this.namespace}: aborting connection`);
         this.backoffCall.abort();
       }
 
       if (this.socket) {
         this.socket.removeAllListeners('message');
         this.once('offline', resolve);
-        this.socket.close();
-
-        return;
+        resolve(this.socket.close());
       }
 
       resolve();
@@ -121,7 +119,8 @@ const Mercury = WebexPlugin.extend({
       webSocketUrl = this.webex.internal.device.webSocketUrl;
     }
 
-    return this.webex.internal.feature.getFeature('developer', 'web-high-availability')
+    return this.webex.internal.feature
+      .getFeature('developer', 'web-high-availability')
       .then((haMessagingEnabled) => {
         if (haMessagingEnabled) {
           return this.webex.internal.services.convertUrlToPriorityHostUrl(webSocketUrl);
@@ -138,13 +137,13 @@ const Mercury = WebexPlugin.extend({
         Object.assign(webSocketUrl.query, {
           outboundWireFormat: 'text',
           bufferStates: true,
-          aliasHttpStatus: true
+          aliasHttpStatus: true,
         });
 
         if (webSharedMercury) {
           Object.assign(webSocketUrl.query, {
             mercuryRegistrationStatus: true,
-            isRegistrationRefreshEnabled: true
+            isRegistrationRefreshEnabled: true,
           });
           Reflect.deleteProperty(webSocketUrl.query, 'bufferStates');
         }
@@ -164,11 +163,12 @@ const Mercury = WebexPlugin.extend({
     socket.on('close', (...args) => this._onclose(...args));
     socket.on('message', (...args) => this._onmessage(...args));
     socket.on('sequence-mismatch', (...args) => this._emit('sequence-mismatch', ...args));
+    socket.on('ping-pong-latency', (...args) => this._emit('ping-pong-latency', ...args));
 
     Promise.all([this._prepareUrl(socketUrl), this.webex.credentials.getUserToken()])
       .then(([webSocketUrl, token]) => {
         if (!this.backoffCall) {
-          const msg = 'mercury: prevent socket open when backoffCall no longer defined';
+          const msg = `${this.namespace}: prevent socket open when backoffCall no longer defined`;
 
           this.logger.info(msg);
 
@@ -183,12 +183,12 @@ const Mercury = WebexPlugin.extend({
           pongTimeout: this.config.pongTimeout,
           token: token.toString(),
           trackingId: `${this.webex.sessionId}_${Date.now()}`,
-          logger: this.logger
+          logger: this.logger,
         };
 
         // if the consumer has supplied request options use them
         if (this.webex.config.defaultMercuryOptions) {
-          this.logger.info('mercury: setting custom options');
+          this.logger.info(`${this.namespace}: setting custom options`);
           options = {...options, ...this.webex.config.defaultMercuryOptions};
         }
 
@@ -196,21 +196,18 @@ const Mercury = WebexPlugin.extend({
         // the socket if it is in the process of being opened.
         this.socket = socket;
 
+        this.logger.info(`${this.namespace} connection url: ${webSocketUrl}`);
+
         return socket.open(webSocketUrl, options);
       })
       .then(() => {
-        this.webex.internal.metrics.submitClientMetrics('web-ha-mercury', {
-          fields: {
-            success: true
-          },
-          tags: {
-            action: 'connected',
-            url: attemptWSUrl
-          }
-        });
+        this.logger.info(
+          `${this.namespace}: connected to mercury, success, action: connected, url: ${attemptWSUrl}`
+        );
         callback();
 
-        return this.webex.internal.feature.getFeature('developer', 'web-high-availability')
+        return this.webex.internal.feature
+          .getFeature('developer', 'web-high-availability')
           .then((haMessagingEnabled) => {
             if (haMessagingEnabled) {
               return this.webex.internal.device.refresh();
@@ -227,21 +224,21 @@ const Mercury = WebexPlugin.extend({
         if (reason.code !== 1006 && this.backoffCall && this.backoffCall.getNumRetries() > 0) {
           this._emit('connection_failed', reason, {retries: this.backoffCall.getNumRetries()});
         }
-        this.logger.info('mercury: connection attempt failed', reason);
+        this.logger.info(`${this.namespace}: connection attempt failed`, reason);
         // UnknownResponse is produced by IE for any 4XXX; treated it like a bad
         // web socket url and let WDM handle the token checking
         if (reason instanceof UnknownResponse) {
-          this.logger.info('mercury: received unknown response code, refreshing device registration');
+          this.logger.info(
+            `${this.namespace}: received unknown response code, refreshing device registration`
+          );
 
-          return this.webex.internal.device.refresh()
-            .then(() => callback(reason));
+          return this.webex.internal.device.refresh().then(() => callback(reason));
         }
         // NotAuthorized implies expired token
         if (reason instanceof NotAuthorized) {
-          this.logger.info('mercury: received authorization error, reauthorizing');
+          this.logger.info(`${this.namespace}: received authorization error, reauthorizing`);
 
-          return this.webex.credentials.refresh({force: true})
-            .then(() => callback(reason));
+          return this.webex.credentials.refresh({force: true}).then(() => callback(reason));
         }
         // // NotFound implies expired web socket url
         // else if (reason instanceof NotFound) {
@@ -252,26 +249,19 @@ const Mercury = WebexPlugin.extend({
         // BadRequest implies current credentials are for a Service Account
         // Forbidden implies current user is not entitle for Webex
         if (reason instanceof BadRequest || reason instanceof Forbidden) {
-          this.logger.warn('mercury: received unrecoverable response from mercury');
+          this.logger.warn(`${this.namespace}: received unrecoverable response from mercury`);
           this.backoffCall.abort();
 
           return callback(reason);
         }
         if (reason instanceof ConnectionError) {
-          return this.webex.internal.feature.getFeature('developer', 'web-high-availability')
+          return this.webex.internal.feature
+            .getFeature('developer', 'web-high-availability')
             .then((haMessagingEnabled) => {
               if (haMessagingEnabled) {
-                this.logger.info('mercury: received a generic connection error, will try to connect to another datacenter');
-                this.webex.internal.metrics.submitClientMetrics('web-ha-mercury', {
-                  fields: {
-                    success: false
-                  },
-                  tags: {
-                    action: 'failed',
-                    error: reason.message,
-                    url: attemptWSUrl
-                  }
-                });
+                this.logger.info(
+                  `${this.namespace}: received a generic connection error, will try to connect to another datacenter. failed, action: 'failed', url: ${attemptWSUrl} error: ${reason.message}`
+                );
 
                 return this.webex.internal.services.markFailedUrl(attemptWSUrl);
               }
@@ -284,7 +274,7 @@ const Mercury = WebexPlugin.extend({
         return callback(reason);
       })
       .catch((reason) => {
-        this.logger.error('mercury: failed to handle connection failure', reason);
+        this.logger.error(`${this.namespace}: failed to handle connection failure`, reason);
         callback(reason);
       });
   },
@@ -299,11 +289,16 @@ const Mercury = WebexPlugin.extend({
 
         this.backoffCall = undefined;
         if (err) {
-          this.logger.info(`mercury: failed to connect after ${call.getNumRetries()} retries; log statement about next retry was inaccurate; ${err}`);
+          this.logger.info(
+            `${
+              this.namespace
+            }: failed to connect after ${call.getNumRetries()} retries; log statement about next retry was inaccurate; ${err}`
+          );
 
           return reject(err);
         }
         this.connected = true;
+        this.hasEverConnected = true;
         this._emit('online');
 
         return resolve();
@@ -311,21 +306,25 @@ const Mercury = WebexPlugin.extend({
 
       // eslint-disable-next-line prefer-reflect
       call = backoff.call((callback) => {
-        this.logger.info(`mercury: executing connection attempt ${call.getNumRetries()}`);
+        this.logger.info(`${this.namespace}: executing connection attempt ${call.getNumRetries()}`);
         this._attemptConnection(webSocketUrl, callback);
       }, onComplete);
 
-      call.setStrategy(new backoff.ExponentialStrategy({
-        initialDelay: this.config.backoffTimeReset,
-        maxDelay: this.config.backoffTimeMax
-      }));
+      call.setStrategy(
+        new backoff.ExponentialStrategy({
+          initialDelay: this.config.backoffTimeReset,
+          maxDelay: this.config.backoffTimeMax,
+        })
+      );
 
-      if (this.config.maxRetries) {
+      if (this.config.initialConnectionMaxRetries && !this.hasEverConnected) {
+        call.failAfter(this.config.initialConnectionMaxRetries);
+      } else if (this.config.maxRetries) {
         call.failAfter(this.config.maxRetries);
       }
 
       call.on('abort', () => {
-        this.logger.info('mercury: connection aborted');
+        this.logger.info(`${this.namespace}: connection aborted`);
         reject(new Error('Mercury Connection Aborted'));
       });
 
@@ -334,15 +333,17 @@ const Mercury = WebexPlugin.extend({
           const number = call.getNumRetries();
           const delay = Math.min(call.strategy_.nextBackoffDelay_, this.config.backoffTimeMax);
 
-          this.logger.info(`mercury: failed to connect; attempting retry ${number + 1} in ${delay} ms`);
+          this.logger.info(
+            `${this.namespace}: failed to connect; attempting retry ${number + 1} in ${delay} ms`
+          );
           /* istanbul ignore if */
           if (process.env.NODE_ENV === 'development') {
-            this.logger.debug('mercury: ', err, err.stack);
+            this.logger.debug(`${this.namespace}: `, err, err.stack);
           }
 
           return;
         }
-        this.logger.info('mercury: connected');
+        this.logger.info(`${this.namespace}: connected`);
       });
 
       call.start();
@@ -354,9 +355,11 @@ const Mercury = WebexPlugin.extend({
   _emit(...args) {
     try {
       this.trigger(...args);
-    }
-    catch (error) {
-      this.logger.error('mercury: error occurred in event handler', error);
+    } catch (error) {
+      this.logger.error(`${this.namespace}: error occurred in event handler`, {
+        error,
+        arguments: args,
+      });
     }
   },
 
@@ -373,7 +376,7 @@ const Mercury = WebexPlugin.extend({
     if ((this.webex[namespace] || this.webex.internal[namespace])[handlerName]) {
       handlers.push({
         name: handlerName,
-        namespace
+        namespace,
       });
     }
 
@@ -395,20 +398,22 @@ const Mercury = WebexPlugin.extend({
 
       switch (event.code) {
         case 1003:
-        // metric: disconnect
-          this.logger.info(`mercury: Mercury service rejected last message; will not reconnect: ${event.reason}`);
+          // metric: disconnect
+          this.logger.info(
+            `${this.namespace}: Mercury service rejected last message; will not reconnect: ${event.reason}`
+          );
           this._emit('offline.permanent', event);
           break;
         case 4000:
           // metric: disconnect
-          this.logger.info('mercury: socket replaced; will not reconnect');
+          this.logger.info(`${this.namespace}: socket replaced; will not reconnect`);
           this._emit('offline.replaced', event);
           break;
         case 1001:
         case 1005:
         case 1006:
         case 1011:
-          this.logger.info('mercury: socket disconnected; reconnecting');
+          this.logger.info(`${this.namespace}: socket disconnected; reconnecting`);
           this._emit('offline.transient', event);
           this._reconnect(socketUrl);
           // metric: disconnect
@@ -416,25 +421,25 @@ const Mercury = WebexPlugin.extend({
           break;
         case 1000:
           if (normalReconnectReasons.includes(reason)) {
-            this.logger.info('mercury: socket disconnected; reconnecting');
+            this.logger.info(`${this.namespace}: socket disconnected; reconnecting`);
             this._emit('offline.transient', event);
             this._reconnect(socketUrl);
             // metric: disconnect
             // if (reason === done forced) metric: force closure
-          }
-          else {
-            this.logger.info('mercury: socket disconnected; will not reconnect');
+          } else {
+            this.logger.info(`${this.namespace}: socket disconnected; will not reconnect`);
             this._emit('offline.permanent', event);
           }
           break;
         default:
-          this.logger.info('mercury: socket disconnected unexpectedly; will not reconnect');
+          this.logger.info(
+            `${this.namespace}: socket disconnected unexpectedly; will not reconnect`
+          );
           // unexpected disconnect
           this._emit('offline.permanent', event);
       }
-    }
-    catch (error) {
-      this.logger.error('mercury: error occurred in close handler', error);
+    } catch (error) {
+      this.logger.error(`${this.namespace}: error occurred in close handler`, error);
     }
   },
 
@@ -442,7 +447,7 @@ const Mercury = WebexPlugin.extend({
     const envelope = event.data;
 
     if (process.env.ENABLE_MERCURY_LOGGING) {
-      this.logger.debug('mercury: message envelope: ', envelope);
+      this.logger.debug(`${this.namespace}: message envelope: `, envelope);
     }
 
     const {data} = envelope;
@@ -450,34 +455,43 @@ const Mercury = WebexPlugin.extend({
     this._applyOverrides(data);
 
     return this._getEventHandlers(data.eventType)
-      .reduce((promise, handler) => promise.then(() => {
-        const {namespace, name} = handler;
-
-        return new Promise((resolve) => resolve((this.webex[namespace] || this.webex.internal[namespace])[name](data)))
-          .catch((reason) => this.logger.error(`mercury: error occurred in autowired event handler for ${data.eventType}`, reason));
-      }), Promise.resolve())
+      .reduce(
+        (promise, handler) =>
+          promise.then(() => {
+            const {namespace, name} = handler;
+
+            return new Promise((resolve) =>
+              resolve((this.webex[namespace] || this.webex.internal[namespace])[name](data))
+            ).catch((reason) =>
+              this.logger.error(
+                `${this.namespace}: error occurred in autowired event handler for ${data.eventType}`,
+                reason
+              )
+            );
+          }),
+        Promise.resolve()
+      )
       .then(() => {
         this._emit('event', event.data);
         const [namespace] = data.eventType.split('.');
 
         if (namespace === data.eventType) {
           this._emit(`event:${namespace}`, envelope);
-        }
-        else {
+        } else {
           this._emit(`event:${namespace}`, envelope);
           this._emit(`event:${data.eventType}`, envelope);
         }
       })
       .catch((reason) => {
-        this.logger.error('mercury: error occurred processing socket message', reason);
+        this.logger.error(`${this.namespace}: error occurred processing socket message`, reason);
       });
   },
 
   _reconnect(webSocketUrl) {
-    this.logger.info('mercury: reconnecting');
+    this.logger.info(`${this.namespace}: reconnecting`);
 
     return this.connect(webSocketUrl);
-  }
+  },
 });
 
 export default Mercury;