noibu-react-native 0.2.2 → 0.2.3

package/dist/api/metroplexSocket.js

@@ -1,3 +1,4 @@
+import { __awaiter } from 'tslib';
 import uuid from 'react-native-uuid';
 import { getUserAgent, stringifyJSON, getVideoRecorderType } from '../utils/function.js';
 import { addSafeEventListener } from '../utils/eventlistener.js';
@@ -10,40 +11,8 @@ import { isDateOverwritten } from '../utils/date.js';
 import { unwrapNoibuWrapped } from '../utils/object.js';
 import { noibuLog } from '../utils/log.js';
 
-/** @module MetroplexSocket */
 /** Manages the socket to Metroplex */
 class MetroplexSocket {
-    _initialURL;
-    ackedOnce;
-    connectionCount;
-    // promise that will resolve once the socket is connected and metroplex has acknowledged
-    connectionPromise;
-    connectionURL;
-    currentConnectionAttempts;
-    forceClosed;
-    helpCodeCb;
-    initialReferingURL;
-    static instance;
-    instanceId;
-    isRetryLoopDisabled;
-    latestReceivedSeqNumStoredTime;
-    latestReceivedSeqNumber;
-    messageSequenceNum;
-    metroRetryFrequencyMS;
-    metroplexTypeLock;
-    pageVisitInfoSent;
-    postURL;
-    previousMessageType;
-    retryMessageQueue;
-    retryMetroplexInterval;
-    scriptInstanceId;
-    sessionLength;
-    sessionStartTime;
-    sessionTimestamp;
-    socket;
-    socketInstanceId;
-    socketCloseCodes;
-    socketOpens;
     /**
      * Creates an instance of metroplex
      * id of script, to make sure only a single socket is open
@@ -165,50 +134,54 @@ class MetroplexSocket {
      * Queues the message if the connection isn't open yet.
      * returns true if message was sent succefully, false otherwise
      */
-    async sendMessage(type, payload) {
-        noibuLog('sendMessage start', { type, payload: JSON.stringify(payload) });
-        // if we have a lock on this specific type, we dont send it
-        if (type in this.metroplexTypeLock ||
-            ClientConfig.getInstance().isClientDisabled) {
-            noibuLog('sendMessage quitting due to', {
-                typeInLock: type in this.metroplexTypeLock,
-                isClientDisabled: ClientConfig.getInstance().isClientDisabled,
-            });
-            return false;
-        }
-        const payloadData = payload;
-        if (type !== WORK_REQUEST_ATT_NAME) {
-            // Increasing the message sequence number for every message we send to metroplex
-            // and move the data to the retry queue.
-            this._addSeqNumToPayload(type, payloadData);
-            // push the message to the retry queue immediately in case socket isnt connected
-            this.retryMessageQueue.push({ payload: payloadData, type });
-            StoredPageVisit.getInstance().checkAndStoreRetryQueue(this.retryMessageQueue, await this.getPageInformation());
-        }
-        // send the socket message if we are connected and have sent page visit info
-        if (this.isConnected() && this.pageVisitInfoSent) {
-            // sending the data to metroplex
-            await this._sendSocketMessage(payloadData);
-        }
-        this.previousMessageType = type;
-        // Only update the last message send if its a page visit with user action
-        // ensure this is done regardless of whether socket is connected or not,
-        // so that pagehide will post PV if user is active but socket is not
-        if (type === PV_METROPLEX_TYPE && payload[PAGE_VISIT_PART_ATT_NAME]) {
-            const events = payload[PAGE_VISIT_PART_ATT_NAME][PV_EVENTS_ATT_NAME]
-                ? payload[PAGE_VISIT_PART_ATT_NAME][PV_EVENTS_ATT_NAME]
-                : [];
-            await this._updateLatestPvTimestamp(events);
-        }
-        return true;
+    sendMessage(type, payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            noibuLog('sendMessage start', { type, payload: JSON.stringify(payload) });
+            // if we have a lock on this specific type, we dont send it
+            if (type in this.metroplexTypeLock ||
+                ClientConfig.getInstance().isClientDisabled) {
+                noibuLog('sendMessage quitting due to', {
+                    typeInLock: type in this.metroplexTypeLock,
+                    isClientDisabled: ClientConfig.getInstance().isClientDisabled,
+                });
+                return false;
+            }
+            const payloadData = payload;
+            if (type !== WORK_REQUEST_ATT_NAME) {
+                // Increasing the message sequence number for every message we send to metroplex
+                // and move the data to the retry queue.
+                this._addSeqNumToPayload(type, payloadData);
+                // push the message to the retry queue immediately in case socket isnt connected
+                this.retryMessageQueue.push({ payload: payloadData, type });
+                StoredPageVisit.getInstance().checkAndStoreRetryQueue(this.retryMessageQueue, yield this.getPageInformation());
+            }
+            // send the socket message if we are connected and have sent page visit info
+            if (this.isConnected() && this.pageVisitInfoSent) {
+                // sending the data to metroplex
+                yield this._sendSocketMessage(payloadData);
+            }
+            this.previousMessageType = type;
+            // Only update the last message send if its a page visit with user action
+            // ensure this is done regardless of whether socket is connected or not,
+            // so that pagehide will post PV if user is active but socket is not
+            if (type === PV_METROPLEX_TYPE && payload[PAGE_VISIT_PART_ATT_NAME]) {
+                const events = payload[PAGE_VISIT_PART_ATT_NAME][PV_EVENTS_ATT_NAME]
+                    ? payload[PAGE_VISIT_PART_ATT_NAME][PV_EVENTS_ATT_NAME]
+                    : [];
+                yield this._updateLatestPvTimestamp(events);
+            }
+            return true;
+        });
     }
     /** Updates the latest pv message sent timestamp if events contain any user steps
      */
-    async _updateLatestPvTimestamp(events) {
-        const userstepsEvents = events.filter(ev => ev[TYPE_ATT_NAME] === USERSTEP_EVENT_TYPE);
-        if (userstepsEvents.length > 0) {
-            await ClientConfig.getInstance().updateLastActiveTime(new Date());
-        }
+    _updateLatestPvTimestamp(events) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userstepsEvents = events.filter(ev => ev[TYPE_ATT_NAME] === USERSTEP_EVENT_TYPE);
+            if (userstepsEvents.length > 0) {
+                yield ClientConfig.getInstance().updateLastActiveTime(new Date());
+            }
+        });
     }
     /** returns true if the socket is either connecting or connected to metroplex */
     isConnected() {
@@ -231,77 +204,79 @@ class MetroplexSocket {
     }
     /** Connects the web socket to metroplex and calls callback upon successfully connecting
      */
-    async handleConnect(forceOpen) {
-        noibuLog('metroplex handleConnect');
-        // if we are connected or about to connect, we do not reset
-        // the socket information
-        if (!forceOpen && (this.isConnected() || this.isConnecting())) {
-            return;
-        }
-        this.currentConnectionAttempts += 1;
-        this.socket = new WebSocket(this.connectionURL, undefined, {
-            headers: {
-                'User-Agent': await getUserAgent(), // must pass useragent explicitly
-            },
-        });
-        this.socketInstanceId = uuid.v4();
-        this.socket.onerror = error => {
-            noibuLog('metroplex handleConnect, onerror', { error });
-            // use for metrics
-            // there is no useful error message/description from this event
-        };
-        // once the socket closes
-        this.socket.onclose = async (event) => {
-            noibuLog('metroplex handleConnect, onclose', { event });
-            // Reset this to prevent sending messages before the PVI is sent on reconnect
-            this.pageVisitInfoSent = false;
-            // we do not reconnect if the page is unloading
-            if (this.forceClosed) {
-                return;
-            }
-            // track socket closure codes and times
-            this.socketCloseCodes.push(`${!isDateOverwritten() ? new Date().toISOString() : ''}:${event.code}`);
-            // we are already in the process of reconnecting
-            // we do not attempt to reconnect yet
-            if (this.isConnecting()) {
-                return;
-            }
-            // Clear the interval that resends unconfirmed msgs so we don't try send while the socket
-            // is and starting back up, after which it will be restarted
-            if (this.retryMetroplexInterval) {
-                clearInterval(this.retryMetroplexInterval);
-            }
-            // if we tried reconnecting too many times we abandon
-            if (this.currentConnectionAttempts >=
-                GET_MAX_METROPLEX_RECONNECTION_NUMBER()) {
-                // if we tried beyond the threshold, we block ourselves a short
-                // while fix the issue
-                await ClientConfig.getInstance().lockClientUntilNextPage('Too many reconnection attempts, locking until next page');
-                return;
-            }
-            // if we tried reconnecting too many times we abandon
-            if (this.connectionCount >= MAX_METROPLEX_CONNECTION_COUNT) {
-                // if we tried beyond the threshold, we block ourselves a short
-                // while while fix the issue
-                await ClientConfig.getInstance().lockClientUntilNextPage('Too many connections, locking until next page');
+    handleConnect(forceOpen) {
+        return __awaiter(this, void 0, void 0, function* () {
+            noibuLog('metroplex handleConnect');
+            // if we are connected or about to connect, we do not reset
+            // the socket information
+            if (!forceOpen && (this.isConnected() || this.isConnecting())) {
                 return;
             }
-            // try to reconnect on close but after a certain delay based off unsuccessful connections
-            setTimeout(() => {
-                this.handleConnect(false);
-            }, this.currentConnectionAttempts ** 2 * GET_METROPLEX_CONSECUTIVE_CONNECTION_DELAY());
-        };
-        // everytime we get a message from the socket
-        this.socket.onmessage = event => {
-            noibuLog('metroplex handleConnect, onmessage', { event });
-            this._onSocketMessage(event);
-        };
-        // the moment we open the socket
-        this.socket.onopen = () => {
-            // track socket open codes and times
-            this.socketOpens.push(`${!isDateOverwritten() ? new Date().toISOString() : ''}`);
-            this._onSocketOpen();
-        };
+            this.currentConnectionAttempts += 1;
+            this.socket = new WebSocket(this.connectionURL, undefined, {
+                headers: {
+                    'User-Agent': yield getUserAgent(), // must pass useragent explicitly
+                },
+            });
+            this.socketInstanceId = uuid.v4();
+            this.socket.onerror = error => {
+                noibuLog('metroplex handleConnect, onerror', { error });
+                // use for metrics
+                // there is no useful error message/description from this event
+            };
+            // once the socket closes
+            this.socket.onclose = (event) => __awaiter(this, void 0, void 0, function* () {
+                noibuLog('metroplex handleConnect, onclose', { event });
+                // Reset this to prevent sending messages before the PVI is sent on reconnect
+                this.pageVisitInfoSent = false;
+                // we do not reconnect if the page is unloading
+                if (this.forceClosed) {
+                    return;
+                }
+                // track socket closure codes and times
+                this.socketCloseCodes.push(`${!isDateOverwritten() ? new Date().toISOString() : ''}:${event.code}`);
+                // we are already in the process of reconnecting
+                // we do not attempt to reconnect yet
+                if (this.isConnecting()) {
+                    return;
+                }
+                // Clear the interval that resends unconfirmed msgs so we don't try send while the socket
+                // is and starting back up, after which it will be restarted
+                if (this.retryMetroplexInterval) {
+                    clearInterval(this.retryMetroplexInterval);
+                }
+                // if we tried reconnecting too many times we abandon
+                if (this.currentConnectionAttempts >=
+                    GET_MAX_METROPLEX_RECONNECTION_NUMBER()) {
+                    // if we tried beyond the threshold, we block ourselves a short
+                    // while fix the issue
+                    yield ClientConfig.getInstance().lockClientUntilNextPage('Too many reconnection attempts, locking until next page');
+                    return;
+                }
+                // if we tried reconnecting too many times we abandon
+                if (this.connectionCount >= MAX_METROPLEX_CONNECTION_COUNT) {
+                    // if we tried beyond the threshold, we block ourselves a short
+                    // while while fix the issue
+                    yield ClientConfig.getInstance().lockClientUntilNextPage('Too many connections, locking until next page');
+                    return;
+                }
+                // try to reconnect on close but after a certain delay based off unsuccessful connections
+                setTimeout(() => {
+                    this.handleConnect(false);
+                }, Math.pow(this.currentConnectionAttempts, 2) * GET_METROPLEX_CONSECUTIVE_CONNECTION_DELAY());
+            });
+            // everytime we get a message from the socket
+            this.socket.onmessage = event => {
+                noibuLog('metroplex handleConnect, onmessage', { event });
+                this._onSocketMessage(event);
+            };
+            // the moment we open the socket
+            this.socket.onopen = () => {
+                // track socket open codes and times
+                this.socketOpens.push(`${!isDateOverwritten() ? new Date().toISOString() : ''}`);
+                this._onSocketOpen();
+            };
+        });
     }
     /**
      * connectSocket will establish a websocket connection to the metroplex
@@ -328,95 +303,96 @@ class MetroplexSocket {
         if (isPageVisit) {
             this.sessionLength = delta;
         }
-        return {
-            ...payload,
-            [END_AT_ATT_NAME]: new Date(this.sessionTimestamp.getTime() + delta).toISOString(),
-        };
+        return Object.assign(Object.assign({}, payload), { [END_AT_ATT_NAME]: new Date(this.sessionTimestamp.getTime() + delta).toISOString() });
     }
     /** open handler for socket */
-    async _onSocketOpen() {
-        // if we are not connected, we do not send any messages
-        if (!this.isConnected() || ClientConfig.getInstance().isClientDisabled) {
-            return;
-        }
-        await this._sendSocketMessage(await this.getPageInformation());
-        // Set this to allow normal page visit and video frag messages to be sent
-        this.pageVisitInfoSent = true;
-        this.currentConnectionAttempts = 0;
-        // Resend the pagevisit or video message type before sending data so reset the prev type
-        this.previousMessageType = '';
-        // attempt to send the unconfirmed messages again
-        await this._sendUnconfirmedMessages(false);
-        // setting up the socket retry mechanism
-        this.setupRetryMechanism();
-        // increasing the connection count everytime we connect
-        this.connectionCount += 1;
+    _onSocketOpen() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // if we are not connected, we do not send any messages
+            if (!this.isConnected() || ClientConfig.getInstance().isClientDisabled) {
+                return;
+            }
+            yield this._sendSocketMessage(yield this.getPageInformation());
+            // Set this to allow normal page visit and video frag messages to be sent
+            this.pageVisitInfoSent = true;
+            this.currentConnectionAttempts = 0;
+            // Resend the pagevisit or video message type before sending data so reset the prev type
+            this.previousMessageType = '';
+            // attempt to send the unconfirmed messages again
+            yield this._sendUnconfirmedMessages(false);
+            // setting up the socket retry mechanism
+            this.setupRetryMechanism();
+            // increasing the connection count everytime we connect
+            this.connectionCount += 1;
+        });
     }
     /** message handler for socket
      * @param  {} event
      */
-    async _onSocketMessage(event) {
-        switch (event.data) {
-            case STOP_STORING_VID_SOCKET_MESSAGE:
-                // stopping vids from being sent
-                this.metroplexTypeLock[VIDEO_METROPLEX_TYPE] = true;
-                StoredMetrics.getInstance().setDidCutVideo();
-                break;
-            case STOP_STORING_PV_SOCKET_MESSAGE:
-                // stopping pv from being sent
-                this.metroplexTypeLock[PV_METROPLEX_TYPE] = true;
-                StoredMetrics.getInstance().setDidCutPv();
-                break;
-            case BLOCK_SOCKET_MESSAGE:
-                // we are disabling collect for 1 day if we get the
-                // block message from metroplex. We are probably on it
-                await ClientConfig.getInstance().lockClient(1440, 'Metroplex blocked script');
-                this.close();
-                break;
-            case CLOSE_CONNECTION_FORCEFULLY:
-                this.close();
-                break;
-            case OK_SOCKET_MESSAGE:
-                // we do nothing on an OK
-                break;
-            default:
-                // we now need to check if we receive text that contains
-                // the text SEQ_NUM. if that is true, then its a seq num
-                // and we need to clear out the retry queue.
-                if (event.data.includes(SEQ_NUM_ATT_NAME)) {
-                    const seqNumSplit = event.data.split(`${SEQ_NUM_ATT_NAME}:`);
-                    if (seqNumSplit.length < 2) {
-                        ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Invalid message received from metroplex while clearing retry queue ${event.data}`, false, SEVERITY.error);
-                        break;
+    _onSocketMessage(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            switch (event.data) {
+                case STOP_STORING_VID_SOCKET_MESSAGE:
+                    // stopping vids from being sent
+                    this.metroplexTypeLock[VIDEO_METROPLEX_TYPE] = true;
+                    StoredMetrics.getInstance().setDidCutVideo();
+                    break;
+                case STOP_STORING_PV_SOCKET_MESSAGE:
+                    // stopping pv from being sent
+                    this.metroplexTypeLock[PV_METROPLEX_TYPE] = true;
+                    StoredMetrics.getInstance().setDidCutPv();
+                    break;
+                case BLOCK_SOCKET_MESSAGE:
+                    // we are disabling collect for 1 day if we get the
+                    // block message from metroplex. We are probably on it
+                    yield ClientConfig.getInstance().lockClient(1440, 'Metroplex blocked script');
+                    this.close();
+                    break;
+                case CLOSE_CONNECTION_FORCEFULLY:
+                    this.close();
+                    break;
+                case OK_SOCKET_MESSAGE:
+                    // we do nothing on an OK
+                    break;
+                default:
+                    // we now need to check if we receive text that contains
+                    // the text SEQ_NUM. if that is true, then its a seq num
+                    // and we need to clear out the retry queue.
+                    if (event.data.includes(SEQ_NUM_ATT_NAME)) {
+                        const seqNumSplit = event.data.split(`${SEQ_NUM_ATT_NAME}:`);
+                        if (seqNumSplit.length < 2) {
+                            ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Invalid message received from metroplex while clearing retry queue ${event.data}`, false, SEVERITY.error);
+                            break;
+                        }
+                        // the second element in the string split is the sequence number
+                        const seqNum = parseInt(seqNumSplit[1], 10);
+                        // ignore sequence num if this is just page info, it will always be -1 and we don't want
+                        // to disable the retry loop on this
+                        if (seqNum === -1) {
+                            break;
+                        }
+                        // we disable the retry loop if we start running behind
+                        if (seqNum <= this.latestReceivedSeqNumber) {
+                            this.isRetryLoopDisabled = true;
+                        }
+                        else {
+                            this.isRetryLoopDisabled = false;
+                            // setting the latest received seqNum
+                            this.latestReceivedSeqNumber = seqNum;
+                            // clear the retry queue when for this seqNum and below
+                            this._clearRetryQueue(seqNum);
+                        }
+                        if (!this.ackedOnce) {
+                            this.ackedOnce = true;
+                        }
                     }
-                    // the second element in the string split is the sequence number
-                    const seqNum = parseInt(seqNumSplit[1], 10);
-                    // ignore sequence num if this is just page info, it will always be -1 and we don't want
-                    // to disable the retry loop on this
-                    if (seqNum === -1) {
+                    if (this._tryProcessHelpCodeResponse(event.data)) {
                         break;
                     }
-                    // we disable the retry loop if we start running behind
-                    if (seqNum <= this.latestReceivedSeqNumber) {
-                        this.isRetryLoopDisabled = true;
-                    }
-                    else {
-                        this.isRetryLoopDisabled = false;
-                        // setting the latest received seqNum
-                        this.latestReceivedSeqNumber = seqNum;
-                        // clear the retry queue when for this seqNum and below
-                        this._clearRetryQueue(seqNum);
-                    }
-                    if (!this.ackedOnce) {
-                        this.ackedOnce = true;
-                    }
-                }
-                if (this._tryProcessHelpCodeResponse(event.data)) {
                     break;
-                }
-                break;
-            // still need to collect the id sent back from metroplex
-        }
+                // still need to collect the id sent back from metroplex
+            }
+        });
     }
     /**
      * Returns true if the message's payload has the payload type given and has a sequence
@@ -437,37 +413,39 @@ class MetroplexSocket {
             this._messagePayloadHasLargerSeqNum(message, PAGE_VISIT_VID_FRAG_ATT_NAME, seqNum));
     }
     /** will resend everything that is in the retry queue */
-    async _sendUnconfirmedMessages(socketWasAlreadyOpen) {
-        noibuLog('_sendUnconfirmedMessages');
-        // we only check once. If the socket is disconnected midway, the events would
-        // still be in the retry queue.
-        if (!this.isConnected() || ClientConfig.getInstance().isClientDisabled) {
-            return;
-        }
-        // We always send if this is on socket open
-        if (socketWasAlreadyOpen) {
-            // we do not send the messages to metroplex if we are falling behind on received
-            // sequence numbers
-            const someTimeAgo = new Date();
-            someTimeAgo.setMilliseconds(someTimeAgo.getMilliseconds() - this.metroRetryFrequencyMS);
-            if (someTimeAgo < this.latestReceivedSeqNumStoredTime) {
+    _sendUnconfirmedMessages(socketWasAlreadyOpen) {
+        return __awaiter(this, void 0, void 0, function* () {
+            noibuLog('_sendUnconfirmedMessages');
+            // we only check once. If the socket is disconnected midway, the events would
+            // still be in the retry queue.
+            if (!this.isConnected() || ClientConfig.getInstance().isClientDisabled) {
                 return;
             }
-            // we do not resend messages to metroplex if we are running behind
-            if (this.isRetryLoopDisabled) {
-                return;
+            // We always send if this is on socket open
+            if (socketWasAlreadyOpen) {
+                // we do not send the messages to metroplex if we are falling behind on received
+                // sequence numbers
+                const someTimeAgo = new Date();
+                someTimeAgo.setMilliseconds(someTimeAgo.getMilliseconds() - this.metroRetryFrequencyMS);
+                if (someTimeAgo < this.latestReceivedSeqNumStoredTime) {
+                    return;
+                }
+                // we do not resend messages to metroplex if we are running behind
+                if (this.isRetryLoopDisabled) {
+                    return;
+                }
             }
-        }
-        // removing all the messages with a blocked type from the retry queue
-        this.retryMessageQueue = this.retryMessageQueue.filter(message => !(message.type in this.metroplexTypeLock));
-        // we dont remove any items from this queue in this function
-        for (let i = 0; i < this.retryMessageQueue.length; i += 1) {
-            const { type, payload } = this.retryMessageQueue[i];
-            // sending the data to metroplex
-            // eslint-disable-next-line no-await-in-loop
-            await this._sendSocketMessage(payload);
-            this.previousMessageType = type;
-        }
+            // removing all the messages with a blocked type from the retry queue
+            this.retryMessageQueue = this.retryMessageQueue.filter(message => !(message.type in this.metroplexTypeLock));
+            // we dont remove any items from this queue in this function
+            for (let i = 0; i < this.retryMessageQueue.length; i += 1) {
+                const { type, payload } = this.retryMessageQueue[i];
+                // sending the data to metroplex
+                // eslint-disable-next-line no-await-in-loop
+                yield this._sendSocketMessage(payload);
+                this.previousMessageType = type;
+            }
+        });
     }
     /** sets up the interval to empty the queue as we receive confirmation messages from metroplex */
     setupRetryMechanism() {
@@ -485,143 +463,149 @@ class MetroplexSocket {
      * will handle the final moments of a page being active. It
      * will try to empty both the queues with beacons.
      */
-    async _handleUnload() {
-        // closing the socket since the page is unloading
-        this.close();
-        // if we disable the client within the pagevisit, we do not
-        // post anything during the unloading.
-        if (ClientConfig.getInstance().isClientDisabled) {
-            return;
-        }
-        // Don't send the final complete PV if the session has become inactive
-        // we already sent the PV when went inactive
-        if (ClientConfig.getInstance().isInactive()) {
-            return;
-        }
-        await this.postFullPageVisit(MAX_BEACON_PAYLOAD_SIZE);
+    _handleUnload() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // closing the socket since the page is unloading
+            this.close();
+            // if we disable the client within the pagevisit, we do not
+            // post anything during the unloading.
+            if (ClientConfig.getInstance().isClientDisabled) {
+                return;
+            }
+            // Don't send the final complete PV if the session has become inactive
+            // we already sent the PV when went inactive
+            if (ClientConfig.getInstance().isInactive()) {
+                return;
+            }
+            yield this.postFullPageVisit(MAX_BEACON_PAYLOAD_SIZE);
+        });
     }
     /**
      * will post full page visit to metroplex. It
      * will try to empty both the queues with beacons.
      */
-    async postFullPageVisit(maxMessageSize) {
-        if (this.retryMessageQueue.length === 0) {
-            return;
-        }
-        // debug counters
-        const postInfo = [];
-        const numDropped = {
-            [VIDEO_METROPLEX_TYPE]: 0,
-            [PV_METROPLEX_TYPE]: 0,
-        };
-        let currentMsgPayloadSize = 0;
-        let currentCompletePv = {
-            [PAGE_VISIT_INFORMATION_ATT_NAME]: await this.getPageInformation(),
-            [PAGE_VISIT_PART_ATT_NAME]: [],
-            [PAGE_VISIT_VID_FRAG_ATT_NAME]: [],
-            [PAGE_VISIT_HTTP_DATA_ATT_NAME]: [],
-            [VIDEO_PART_COUNT_ATT_NAME]: this.connectionCount,
-        };
-        currentCompletePv[PAGE_VISIT_INFORMATION_ATT_NAME][IS_LAST_ATT_NAME] = true;
-        const pageInfo = await this.getPageInformation();
-        this.retryMessageQueue.forEach(msg => {
-            // can't use two variables types in obj deconstruction
-            // eslint-disable-next-line  prefer-const
-            let { type, payload } = msg;
-            // If the message is larger than the beacon limit then skip to the next message
-            const currentPayloadSize = new Blob([stringifyJSON(payload)]).size;
-            if (currentPayloadSize > maxMessageSize) {
-                // increment dropped count for this type
-                numDropped[type] += 1;
+    postFullPageVisit(maxMessageSize) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.retryMessageQueue.length === 0) {
                 return;
             }
-            currentMsgPayloadSize += currentPayloadSize;
-            if (currentMsgPayloadSize >= maxMessageSize) {
-                this.postMessage(currentCompletePv);
-                // add to post info
+            // debug counters
+            const postInfo = [];
+            const numDropped = {
+                [VIDEO_METROPLEX_TYPE]: 0,
+                [PV_METROPLEX_TYPE]: 0,
+            };
+            let currentMsgPayloadSize = 0;
+            let currentCompletePv = {
+                [PAGE_VISIT_INFORMATION_ATT_NAME]: yield this.getPageInformation(),
+                [PAGE_VISIT_PART_ATT_NAME]: [],
+                [PAGE_VISIT_VID_FRAG_ATT_NAME]: [],
+                [PAGE_VISIT_HTTP_DATA_ATT_NAME]: [],
+                [VIDEO_PART_COUNT_ATT_NAME]: this.connectionCount,
+            };
+            currentCompletePv[PAGE_VISIT_INFORMATION_ATT_NAME][IS_LAST_ATT_NAME] = true;
+            const pageInfo = yield this.getPageInformation();
+            this.retryMessageQueue.forEach(msg => {
+                // can't use two variables types in obj deconstruction
+                // eslint-disable-next-line  prefer-const
+                let { type, payload } = msg;
+                // If the message is larger than the beacon limit then skip to the next message
+                const currentPayloadSize = new Blob([stringifyJSON(payload)]).size;
+                if (currentPayloadSize > maxMessageSize) {
+                    // increment dropped count for this type
+                    numDropped[type] += 1;
+                    return;
+                }
+                currentMsgPayloadSize += currentPayloadSize;
+                if (currentMsgPayloadSize >= maxMessageSize) {
+                    this.postMessage(currentCompletePv);
+                    // add to post info
+                    let postInfoMessage = `Vid: ${currentCompletePv[PAGE_VISIT_VID_FRAG_ATT_NAME].length}`;
+                    postInfoMessage += ` PV: ${currentCompletePv[PAGE_VISIT_PART_ATT_NAME].length}`;
+                    postInfoMessage += ` HTTP: ${currentCompletePv[PAGE_VISIT_HTTP_DATA_ATT_NAME].length},`;
+                    postInfo.push(postInfoMessage);
+                    // resetting currentCompletePv, since we need to keep adding
+                    // events to a blank object to send to metroplex.
+                    // retain the video part count, so we don't overwrite anything
+                    currentCompletePv = {
+                        [PAGE_VISIT_INFORMATION_ATT_NAME]: pageInfo,
+                        [PAGE_VISIT_PART_ATT_NAME]: [],
+                        [PAGE_VISIT_VID_FRAG_ATT_NAME]: [],
+                        [PAGE_VISIT_HTTP_DATA_ATT_NAME]: [],
+                        [VIDEO_PART_COUNT_ATT_NAME]: currentCompletePv[VIDEO_PART_COUNT_ATT_NAME],
+                    };
+                    currentCompletePv[PAGE_VISIT_INFORMATION_ATT_NAME][IS_LAST_ATT_NAME] =
+                        true;
+                    // resetting the message size based on what is being added
+                    currentMsgPayloadSize = currentPayloadSize;
+                }
+                switch (type) {
+                    case VIDEO_METROPLEX_TYPE:
+                        currentCompletePv[PAGE_VISIT_VID_FRAG_ATT_NAME].push(payload[PAGE_VISIT_VID_FRAG_ATT_NAME]);
+                        break;
+                    case PV_METROPLEX_TYPE:
+                        currentCompletePv[PAGE_VISIT_PART_ATT_NAME].push(payload[PAGE_VISIT_PART_ATT_NAME]);
+                        break;
+                    case HTTP_DATA_METROPLEX_TYPE:
+                        currentCompletePv[PAGE_VISIT_HTTP_DATA_ATT_NAME].push(payload[PAGE_VISIT_HTTP_DATA_ATT_NAME]);
+                        break;
+                }
+            });
+            this.postMessage(currentCompletePv);
+            // debug log if large retry message queue
+            if (this.retryMessageQueue.length > 100) {
                 let postInfoMessage = `Vid: ${currentCompletePv[PAGE_VISIT_VID_FRAG_ATT_NAME].length}`;
                 postInfoMessage += ` PV: ${currentCompletePv[PAGE_VISIT_PART_ATT_NAME].length}`;
                 postInfoMessage += ` HTTP: ${currentCompletePv[PAGE_VISIT_HTTP_DATA_ATT_NAME].length},`;
                 postInfo.push(postInfoMessage);
-                // resetting currentCompletePv, since we need to keep adding
-                // events to a blank object to send to metroplex.
-                // retain the video part count, so we don't overwrite anything
-                currentCompletePv = {
-                    [PAGE_VISIT_INFORMATION_ATT_NAME]: pageInfo,
-                    [PAGE_VISIT_PART_ATT_NAME]: [],
-                    [PAGE_VISIT_VID_FRAG_ATT_NAME]: [],
-                    [PAGE_VISIT_HTTP_DATA_ATT_NAME]: [],
-                    [VIDEO_PART_COUNT_ATT_NAME]: currentCompletePv[VIDEO_PART_COUNT_ATT_NAME],
-                };
-                currentCompletePv[PAGE_VISIT_INFORMATION_ATT_NAME][IS_LAST_ATT_NAME] =
-                    true;
-                // resetting the message size based on what is being added
-                currentMsgPayloadSize = currentPayloadSize;
-            }
-            switch (type) {
-                case VIDEO_METROPLEX_TYPE:
-                    currentCompletePv[PAGE_VISIT_VID_FRAG_ATT_NAME].push(payload[PAGE_VISIT_VID_FRAG_ATT_NAME]);
-                    break;
-                case PV_METROPLEX_TYPE:
-                    currentCompletePv[PAGE_VISIT_PART_ATT_NAME].push(payload[PAGE_VISIT_PART_ATT_NAME]);
-                    break;
-                case HTTP_DATA_METROPLEX_TYPE:
-                    currentCompletePv[PAGE_VISIT_HTTP_DATA_ATT_NAME].push(payload[PAGE_VISIT_HTTP_DATA_ATT_NAME]);
-                    break;
+                // we completed posted the full pv, send the confirmation debug logs
+                // build the debug message
+                let message = 'POST Full PV complete';
+                // POST counts
+                message += `, POSTs count: ${postInfo.length}`;
+                message += `, POSTs info: ${stringifyJSON(postInfo)}`;
+                // Initial retry message queue size
+                message += `, Retry message queue size: ${this.retryMessageQueue.length}`;
+                // Num drops
+                if (numDropped[VIDEO_METROPLEX_TYPE] > 0) {
+                    message += `, Video parts dropped: ${numDropped[VIDEO_METROPLEX_TYPE]}`;
+                }
+                if (numDropped[PV_METROPLEX_TYPE] > 0) {
+                    message += `, Page visit parts dropped: ${numDropped[PV_METROPLEX_TYPE]}`;
+                }
+                if (numDropped[HTTP_DATA_METROPLEX_TYPE] > 0) {
+                    message += `, HTTP data parts dropped: ${numDropped[HTTP_DATA_METROPLEX_TYPE]}`;
+                }
+                // Sequence info
+                message += `, Sequence Info: Latest ${this.messageSequenceNum}`;
+                message += ` Ack'd ${this.latestReceivedSeqNumStoredTime} ${this.latestReceivedSeqNumber}`;
+                // if client was disabled (due to inactive or otherwise) enable briefly so the
+                // debug message gets through
+                const clientDisabled = ClientConfig.getInstance().isClientDisabled;
+                ClientConfig.getInstance().isClientDisabled = false;
+                ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(message, clientDisabled, SEVERITY.warn);
             }
         });
-        this.postMessage(currentCompletePv);
-        // debug log if large retry message queue
-        if (this.retryMessageQueue.length > 100) {
-            let postInfoMessage = `Vid: ${currentCompletePv[PAGE_VISIT_VID_FRAG_ATT_NAME].length}`;
-            postInfoMessage += ` PV: ${currentCompletePv[PAGE_VISIT_PART_ATT_NAME].length}`;
-            postInfoMessage += ` HTTP: ${currentCompletePv[PAGE_VISIT_HTTP_DATA_ATT_NAME].length},`;
-            postInfo.push(postInfoMessage);
-            // we completed posted the full pv, send the confirmation debug logs
-            // build the debug message
-            let message = 'POST Full PV complete';
-            // POST counts
-            message += `, POSTs count: ${postInfo.length}`;
-            message += `, POSTs info: ${stringifyJSON(postInfo)}`;
-            // Initial retry message queue size
-            message += `, Retry message queue size: ${this.retryMessageQueue.length}`;
-            // Num drops
-            if (numDropped[VIDEO_METROPLEX_TYPE] > 0) {
-                message += `, Video parts dropped: ${numDropped[VIDEO_METROPLEX_TYPE]}`;
-            }
-            if (numDropped[PV_METROPLEX_TYPE] > 0) {
-                message += `, Page visit parts dropped: ${numDropped[PV_METROPLEX_TYPE]}`;
-            }
-            if (numDropped[HTTP_DATA_METROPLEX_TYPE] > 0) {
-                message += `, HTTP data parts dropped: ${numDropped[HTTP_DATA_METROPLEX_TYPE]}`;
-            }
-            // Sequence info
-            message += `, Sequence Info: Latest ${this.messageSequenceNum}`;
-            message += ` Ack'd ${this.latestReceivedSeqNumStoredTime} ${this.latestReceivedSeqNumber}`;
-            // if client was disabled (due to inactive or otherwise) enable briefly so the
-            // debug message gets through
-            const clientDisabled = ClientConfig.getInstance().isClientDisabled;
-            ClientConfig.getInstance().isClientDisabled = false;
-            ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(message, clientDisabled, SEVERITY.warn);
-        }
     }
     /**
      * will send a message to metroplex via a post request that will outlive the current page
      */
-    async postMessage(msg) {
-        const updatedMsg = msg;
-        // ensure a unique video part number each call
-        updatedMsg[VIDEO_PART_COUNT_ATT_NAME] += 1;
-        // we send the remainder elements
-        unwrapNoibuWrapped(fetch)(this.postURL, {
-            method: 'POST',
-            headers: {
-                'content-type': 'application/json',
-                'User-Agent': await getUserAgent(),
-            },
-            body: stringifyJSON(updatedMsg),
-            // keep alive outlives the current page, its the same as beacon
-            keepalive: true,
+    postMessage(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const updatedMsg = msg;
+            // ensure a unique video part number each call
+            updatedMsg[VIDEO_PART_COUNT_ATT_NAME] += 1;
+            // we send the remainder elements
+            unwrapNoibuWrapped(fetch)(this.postURL, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    'User-Agent': yield getUserAgent(),
+                },
+                body: stringifyJSON(updatedMsg),
+                // keep alive outlives the current page, its the same as beacon
+                keepalive: true,
+            });
         });
     }
     /**
@@ -629,60 +613,66 @@ class MetroplexSocket {
      * is active and returns true. If inactive the session and socket are closed
      * and this method returns false.
      */
-    async _sendSocketMessage(payload) {
-        noibuLog('_sendSocketMessage');
-        const closeIfInactive = await this.closeIfInactive();
-        if (closeIfInactive) {
-            noibuLog('_sendSocketMessage dropped due to', { closeIfInactive });
-            return;
-        }
-        const payloadJson = stringifyJSON(payload);
-        noibuLog(`_sendSocketMessage sending: ${payloadJson}`);
-        if (this.socket) {
-            this.socket.send(payloadJson);
-        }
+    _sendSocketMessage(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            noibuLog('_sendSocketMessage');
+            const closeIfInactive = yield this.closeIfInactive();
+            if (closeIfInactive) {
+                noibuLog('_sendSocketMessage dropped due to', { closeIfInactive });
+                return;
+            }
+            const payloadJson = stringifyJSON(payload);
+            noibuLog(`_sendSocketMessage sending: ${payloadJson}`);
+            if (this.socket) {
+                this.socket.send(payloadJson);
+            }
+        });
     }
     /**
      * Closes the socket connection if the session is inactive. Returns true if the
      * session is inactive
      */
-    async closeIfInactive() {
-        const inactive = ClientConfig.getInstance().isInactive();
-        // if we weren't already inactive, go to inactive state
-        if (inactive && !ClientConfig.getInstance().isClientDisabled) {
-            // lock the client for 1 minute, since the lock expires
-            // only on new page loads this will lock the client until
-            // the next page is loaded.
-            await ClientConfig.getInstance().lockClientUntilNextPage('Session is inactive, locking until next page');
-            this.close();
-            Promise.all([
-                // post metrics now so we don't include events after going inactive
-                StoredMetrics.getInstance().postMetrics(),
-                // post retry queue now so we don't include event after going inactive
-                this.postFullPageVisit(MAX_BEACON_PAYLOAD_SIZE),
-            ]);
-        }
-        return inactive;
+    closeIfInactive() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const inactive = ClientConfig.getInstance().isInactive();
+            // if we weren't already inactive, go to inactive state
+            if (inactive && !ClientConfig.getInstance().isClientDisabled) {
+                // lock the client for 1 minute, since the lock expires
+                // only on new page loads this will lock the client until
+                // the next page is loaded.
+                yield ClientConfig.getInstance().lockClientUntilNextPage('Session is inactive, locking until next page');
+                this.close();
+                Promise.all([
+                    // post metrics now so we don't include events after going inactive
+                    StoredMetrics.getInstance().postMetrics(),
+                    // post retry queue now so we don't include event after going inactive
+                    this.postFullPageVisit(MAX_BEACON_PAYLOAD_SIZE),
+                ]);
+            }
+            return inactive;
+        });
     }
     /** will get page information, calling this will increase the connection count */
-    async getPageInformation() {
-        return {
-            [BROWSER_ID_ATT_NAME]: ClientConfig.getInstance().browserId,
-            [PV_ID_ATT_NAME]: ClientConfig.getInstance().pageVisitId,
-            [VER_ATT_NAME]: CURRENT_PV_VERSION,
-            [PV_SEQ_ATT_NAME]: await ClientConfig.getInstance().getPageVisitSeq(),
-            [ON_URL_ATT_NAME]: this._initialURL,
-            [REF_URL_ATT_NAME]: this.initialReferingURL,
-            [STARTED_AT_ATT_NAME]: this.sessionTimestamp.toISOString(),
-            [CONN_COUNT_ATT_NAME]: this.connectionCount,
-            [COLLECT_VER_ATT_NAME]: CURRENT_NOIBUJS_VERSION,
-            [IS_LAST_ATT_NAME]: false,
-            [SCRIPT_ID_ATT_NAME]: GET_SCRIPT_ID(),
-            [SCRIPT_INSTANCE_ID_ATT_NAME]: this.scriptInstanceId,
-            [METROPLEX_SOCKET_INSTANCE_ID_ATT_NAME]: this.instanceId,
-            [SOCKET_INSTANCE_ID_ATT_NAME]: this.socketInstanceId,
-            [VIDEO_RECORDER_ATT_NAME]: await getVideoRecorderType(),
-        };
+    getPageInformation() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {
+                [BROWSER_ID_ATT_NAME]: ClientConfig.getInstance().browserId,
+                [PV_ID_ATT_NAME]: ClientConfig.getInstance().pageVisitId,
+                [VER_ATT_NAME]: CURRENT_PV_VERSION,
+                [PV_SEQ_ATT_NAME]: yield ClientConfig.getInstance().getPageVisitSeq(),
+                [ON_URL_ATT_NAME]: this._initialURL,
+                [REF_URL_ATT_NAME]: this.initialReferingURL,
+                [STARTED_AT_ATT_NAME]: this.sessionTimestamp.toISOString(),
+                [CONN_COUNT_ATT_NAME]: this.connectionCount,
+                [COLLECT_VER_ATT_NAME]: CURRENT_NOIBUJS_VERSION,
+                [IS_LAST_ATT_NAME]: false,
+                [SCRIPT_ID_ATT_NAME]: GET_SCRIPT_ID(),
+                [SCRIPT_INSTANCE_ID_ATT_NAME]: this.scriptInstanceId,
+                [METROPLEX_SOCKET_INSTANCE_ID_ATT_NAME]: this.instanceId,
+                [SOCKET_INSTANCE_ID_ATT_NAME]: this.socketInstanceId,
+                [VIDEO_RECORDER_ATT_NAME]: yield getVideoRecorderType(),
+            };
+        });
     }
     /**
      * Try to parse help code response and fire custom event