noibu-react-native 0.2.6 → 0.2.7

package/dist/api/{metroplexSocket.js → MetroplexSocket.js}

@@ -1,17 +1,37 @@
 import { __awaiter } from 'tslib';
 import uuid from 'react-native-uuid';
-import { getUserAgent, stringifyJSON, getVideoRecorderType } from '../utils/function.js';
+import { Platform } from 'react-native';
+import { MetroplexRoute } from '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
+import { getUserAgent, stringifyJSON } from '../utils/function.js';
 import { addSafeEventListener } from '../utils/eventlistener.js';
-import { GET_METROPLEX_BASE_SOCKET_URL, METROPLEX_FRAG_ROUTE, GET_METROPLEX_POST_URL, METROPLEX_RETRY_FREQUENCY, SEQ_NUM_ATT_NAME, WORK_REQUEST_ATT_NAME, HELP_CODE_ATT_NAME, PV_METROPLEX_TYPE, PAGE_VISIT_PART_ATT_NAME, PV_EVENTS_ATT_NAME, TYPE_ATT_NAME, USERSTEP_EVENT_TYPE, GET_MAX_METROPLEX_RECONNECTION_NUMBER, MAX_METROPLEX_CONNECTION_COUNT, GET_METROPLEX_CONSECUTIVE_CONNECTION_DELAY, END_AT_ATT_NAME, SEVERITY, OK_SOCKET_MESSAGE, CLOSE_CONNECTION_FORCEFULLY, BLOCK_SOCKET_MESSAGE, STOP_STORING_PV_SOCKET_MESSAGE, STOP_STORING_VID_SOCKET_MESSAGE, VIDEO_METROPLEX_TYPE, PAGE_VISIT_VID_FRAG_ATT_NAME, MAX_BEACON_PAYLOAD_SIZE, PAGE_VISIT_INFORMATION_ATT_NAME, PAGE_VISIT_HTTP_DATA_ATT_NAME, VIDEO_PART_COUNT_ATT_NAME, IS_LAST_ATT_NAME, HTTP_DATA_METROPLEX_TYPE, BROWSER_ID_ATT_NAME, PV_ID_ATT_NAME, VER_ATT_NAME, CURRENT_PV_VERSION, PV_SEQ_ATT_NAME, ON_URL_ATT_NAME, REF_URL_ATT_NAME, STARTED_AT_ATT_NAME, CONN_COUNT_ATT_NAME, COLLECT_VER_ATT_NAME, CURRENT_NOIBUJS_VERSION, SCRIPT_ID_ATT_NAME, GET_SCRIPT_ID, SCRIPT_INSTANCE_ID_ATT_NAME, METROPLEX_SOCKET_INSTANCE_ID_ATT_NAME, SOCKET_INSTANCE_ID_ATT_NAME, VIDEO_RECORDER_ATT_NAME, META_DATA_METROPLEX_TYPE, PAGE_VISIT_META_DATA_ATT_NAME, MAX_RETRY_MSG_Q_SIZE } from '../constants.js';
-import ClientConfig from './clientConfig.js';
-import StoredMetrics from './storedMetrics.js';
-import StoredPageVisit from './storedPageVisit.js';
+import { GET_METROPLEX_BASE_SOCKET_URL, GET_METROPLEX_POST_URL, GET_MAX_METROPLEX_RECONNECTION_NUMBER, GET_METROPLEX_CONSECUTIVE_CONNECTION_DELAY, SEVERITY, MAX_BEACON_PAYLOAD_SIZE, CURRENT_NOIBUJS_VERSION, GET_SCRIPT_ID } from '../constants.js';
+import ClientConfig from './ClientConfig.js';
+import StoredMetrics from './StoredMetrics.js';
+import StoredPageVisit from './StoredPageVisit.js';
 import { safePerformanceNow } from '../utils/performance.js';
 import { isDateOverwritten } from '../utils/date.js';
 import { unwrapNoibuWrapped } from '../utils/object.js';
 import { noibuLog } from '../utils/log.js';
 import { Singleton } from '../monitors/BaseMonitor.js';
+import { WebsocketMessageType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/WebsocketMessageType.js';
+import { WorkRequestMessageType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/WorkRequestMessageType.js';
+import { EventType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/EventType.js';
+import { InboundMessageType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/InboundMessageType.js';
 
+/**
+ * Grab the video recorder type based on the device we run the app on.
+ */
+function getVideoRecorderType() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (Platform.OS === 'android') {
+            return 'AndroidNative';
+        }
+        if (Platform.OS === 'ios') {
+            return 'IOSNative';
+        }
+        return 'RRWeb'; // should never happen
+    });
+}
 /**
  * Implements rolling window of specified size,
  * but only makes a cut once array length exceeds 150%.
@@ -35,6 +55,13 @@ function createSlidingArrayOfSize(size, arraySource = [], downsizeThreshold = 1.
         },
     });
 }
+// gets the frequency at which the client resends the message that were not confirmed by metroplex
+const METROPLEX_RETRY_FREQUENCY = 30000;
+// current PageVisitManager version to be sent from front end services
+const CURRENT_PV_VERSION = 5;
+// maximum number of connection a single page visit can reach
+const MAX_METROPLEX_CONNECTION_COUNT = 100;
+const MAX_RETRY_MSG_Q_SIZE = 500;
 /** Manages the socket to Metroplex */
 class MetroplexSocket extends Singleton {
     /**
@@ -59,11 +86,10 @@ class MetroplexSocket extends Singleton {
         this.connectionCount = 0;
         // session start time, used to calculate accurate end time
         this.sessionStartTime = safePerformanceNow();
-        this.connectionPromise = null;
-        // Whether or not we have sent the page visit information after connecting the socket
+        // Whether we have sent the page visit information after connecting the socket
         this.pageVisitInfoSent = false;
         // socket connection url
-        this.connectionURL = `${GET_METROPLEX_BASE_SOCKET_URL()}/${METROPLEX_FRAG_ROUTE}`;
+        this.connectionURL = `${GET_METROPLEX_BASE_SOCKET_URL()}/${MetroplexRoute.PageVisitPart}`;
         // post endpoint for the same events we would send to the socket
         this.postURL = GET_METROPLEX_POST_URL();
         // sequence number of the message sent to metroplex
@@ -98,75 +124,91 @@ class MetroplexSocket extends Singleton {
         this.metroRetryFrequencyMS = METROPLEX_RETRY_FREQUENCY;
         this.retryMetroplexInterval = null;
         this.helpCodeCb = null;
-        noibuLog('Metroplex constructor', {
-            initialURL: this.initialURL,
-            scriptInstanceId,
-        });
+        noibuLog('Metroplex constructor', { initialURL: this.initialURL, scriptInstanceId });
         this.scriptInstanceId = scriptInstanceId;
-        // Connect the WS
         this.connectionPromise = this.connectSocket();
         // Set up the offload events immediately
         this._setupOffloadEvents();
     }
+    /**
+     * connectSocket will establish a websocket connection to the metroplex
+     * service
+     */
+    connectSocket() {
+        if (this.isConnected() || this.isConnecting()) {
+            // self resolving promise since we are already ready to send
+            // requests, if we did reach state 1, we already sent initial
+            // request, thus not sending it again.
+            return this.connectionPromise;
+        }
+        // we return a promisified socket resolver to be able to chain the
+        // opening of the socket
+        return this.handleConnect(false);
+    }
+    /** sets up events that will trigger the event queue to be emptied */
+    _setupOffloadEvents() {
+        // when the page hides we try getting all the events
+        // and empty the event and retry queue.
+        addSafeEventListener(window, 'pagehide', () => this._handleUnload(), false);
+    }
     /**
      * Adds the seq num field to the given payload depending on whether its
      * a page visit part or video frag
      */
-    _addSeqNumToPayload(type, payload) {
-        const newPayload = Object.assign({}, payload);
-        const key = MetroplexSocket.typeToPayloadPropMap[type];
-        if (key) {
-            newPayload[key][SEQ_NUM_ATT_NAME] = this.messageSequenceNum;
+    _addSeqNumToPayload(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { type, payload } = message;
+            /**
+             * Increasing the message sequence number for every message we send to metroplex
+             * and move the data to the retry queue.
+             */
             this.messageSequenceNum += 1;
-        }
-        return newPayload;
+            const newMessage = {
+                type,
+                payload: Object.assign(Object.assign({}, payload), { seq_num: this.messageSequenceNum }),
+            };
+            /** push the message to the retry queue immediately in case socket isnt connected */
+            this.retryMessageQueue.push(newMessage);
+            StoredPageVisit.getInstance().checkAndStoreRetryQueue(this.retryMessageQueue, yield this.getPageInformation());
+            return newMessage;
+        });
     }
     /** requests help code and saves a callback to be called on response */
     requestHelpCode(cb) {
         this.helpCodeCb = cb;
-        return MetroplexSocket.getInstance().sendMessage(WORK_REQUEST_ATT_NAME, {
-            [WORK_REQUEST_ATT_NAME]: HELP_CODE_ATT_NAME,
-        });
+        return this.sendMessage({ type: WebsocketMessageType.WorkRequest, payload: WorkRequestMessageType.HelpCode });
     }
     /**
      * Immediately sends a message to Metroplex over the web socket
      * Queues the message if the connection isn't open yet.
      * returns true if message was sent succefully, false otherwise
      */
-    sendMessage(type, payload) {
+    sendMessage(message) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { type } = message;
             noibuLog('sendMessage start', { type });
             // if we have a lock on this specific type, we dont send it
-            if (type in this.metroplexTypeLock ||
-                ClientConfig.getInstance().isClientDisabled) {
+            if (this.metroplexTypeLock[type] || ClientConfig.getInstance().isClientDisabled) {
                 noibuLog('sendMessage quitting due to', {
-                    typeInLock: type in this.metroplexTypeLock,
+                    typeInLock: this.metroplexTypeLock[type] ? `${type} locked` : false,
                     isClientDisabled: ClientConfig.getInstance().isClientDisabled,
                 });
                 return false;
             }
-            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, payload);
-                // push the message to the retry queue immediately in case socket isnt connected
-                this.retryMessageQueue.push({ payload, type });
-                StoredPageVisit.getInstance().checkAndStoreRetryQueue(this.retryMessageQueue, yield this.getPageInformation());
-            }
+            const withSeqNum = type === WebsocketMessageType.WorkRequest
+                ? message
+                : yield this._addSeqNumToPayload(message);
             // 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(payload);
+                yield this.sendSocketMessage({ [withSeqNum.type]: withSeqNum.payload });
             }
             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);
+            if (withSeqNum.type === WebsocketMessageType.PageVisitPart) {
+                yield this._updateLatestPvTimestamp(withSeqNum.payload.events || []);
             }
             return true;
         });
@@ -175,7 +217,7 @@ class MetroplexSocket extends Singleton {
      */
     _updateLatestPvTimestamp(events) {
         return __awaiter(this, void 0, void 0, function* () {
-            const userstepsEvents = events.filter(ev => ev[TYPE_ATT_NAME] === USERSTEP_EVENT_TYPE);
+            const userstepsEvents = events.filter(ev => ev.type === EventType.UserStep);
             if (userstepsEvents.length > 0) {
                 yield ClientConfig.getInstance().updateLastActiveTime(new Date());
             }
@@ -244,18 +286,21 @@ class MetroplexSocket extends Singleton {
                     clearInterval(this.retryMetroplexInterval);
                 }
                 // if we tried reconnecting too many times we abandon
-                if (this.currentConnectionAttempts >=
-                    GET_MAX_METROPLEX_RECONNECTION_NUMBER()) {
+                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');
+                    yield ClientConfig.getInstance().lockClientUntilNextPage({
+                        msg: '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 fix the issue
-                    yield ClientConfig.getInstance().lockClientUntilNextPage('Too many connections, locking until next page');
+                    yield ClientConfig.getInstance().lockClientUntilNextPage({
+                        msg: 'Too many connections, locking until next page',
+                    });
                     return;
                 }
                 // try to reconnect on close but after a certain delay based off unsuccessful connections
@@ -265,7 +310,7 @@ class MetroplexSocket extends Singleton {
             });
             // everytime we get a message from the socket
             this.socket.onmessage = event => {
-                noibuLog('metroplex handleConnect, onmessage', { event });
+                noibuLog('metroplex handleConnect, onmessage', event);
                 this._onSocketMessage(event);
             };
             // the moment we open the socket
@@ -276,32 +321,14 @@ class MetroplexSocket extends Singleton {
             };
         });
     }
-    /**
-     * connectSocket will establish a websocket connection to the metroplex
-     * service
-     */
-    connectSocket() {
-        if (this.isConnected() || this.isConnecting()) {
-            // self resolving promise since we are already ready to send
-            // requests, if we did reach state 1, we already sent initial
-            // request, thus not sending it again.
-            return this.connectionPromise;
-        }
-        // we return a promisified socket resolver to be able to chain the
-        // opening of the socket
-        return this.handleConnect(false);
-    }
-    /** Calculates and sets the end_at field of the payload
-     * @param  {} payload
-     * @param  {} isPageVisit
-     */
+    /** Calculates and sets the end_at field of the payload   */
     addEndTimeToPayload(payload, isPageVisit) {
         const delta = Math.ceil(safePerformanceNow() - this.sessionStartTime);
         // update session length if this is a page visit event
         if (isPageVisit) {
             this.sessionLength = delta;
         }
-        return Object.assign(Object.assign({}, payload), { [END_AT_ATT_NAME]: new Date(this.sessionTimestamp.getTime() + delta).toISOString() });
+        return Object.assign(Object.assign({}, payload), { end_at: new Date(this.sessionTimestamp.getTime() + delta).toISOString() });
     }
     /** open handler for socket */
     _onSocketOpen() {
@@ -310,7 +337,7 @@ class MetroplexSocket extends Singleton {
             if (!this.isConnected() || ClientConfig.getInstance().isClientDisabled) {
                 return;
             }
-            yield this._sendSocketMessage(yield this.getPageInformation());
+            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;
@@ -324,32 +351,30 @@ class MetroplexSocket extends Singleton {
             this.connectionCount += 1;
         });
     }
-    /** message handler for socket
-     * @param  {} event
-     */
+    /** message handler for socket  */
     _onSocketMessage(event) {
         return __awaiter(this, void 0, void 0, function* () {
             switch (event.data) {
-                case STOP_STORING_VID_SOCKET_MESSAGE:
+                case InboundMessageType.VideoBlock:
                     // stopping vids from being sent
-                    this.metroplexTypeLock[VIDEO_METROPLEX_TYPE] = true;
+                    this.metroplexTypeLock.pvvf = true;
                     StoredMetrics.getInstance().setDidCutVideo();
                     break;
-                case STOP_STORING_PV_SOCKET_MESSAGE:
+                case InboundMessageType.PageVisitBlock:
                     // stopping pv from being sent
-                    this.metroplexTypeLock[PV_METROPLEX_TYPE] = true;
+                    this.metroplexTypeLock.pvp = true;
                     StoredMetrics.getInstance().setDidCutPv();
                     break;
-                case BLOCK_SOCKET_MESSAGE:
+                case InboundMessageType.FullBlock:
                     // 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');
+                    yield ClientConfig.getInstance().lockClient(1440, { msg: 'Metroplex blocked script' });
                     this.close();
                     break;
-                case CLOSE_CONNECTION_FORCEFULLY:
+                case InboundMessageType.CloseConnection:
                     this.close();
                     break;
-                case OK_SOCKET_MESSAGE:
+                case InboundMessageType.OK:
                     // we do nothing on an OK
                     break;
                 default:
@@ -359,10 +384,10 @@ class MetroplexSocket extends Singleton {
                     // 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 (event.data.includes('seq_num')) {
+                        const seqNumSplit = event.data.split('seq_num:');
                         if (seqNumSplit.length < 2) {
-                            ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Invalid message received from metroplex while clearing retry queue ${event.data}`, false, SEVERITY.error);
+                            ClientConfig.getInstance().postInternalError({ msg: `Invalid message received from metroplex while clearing retry queue`, data: event.data }, false, SEVERITY.error);
                             break;
                         }
                         // the second element in the string split is the sequence number
@@ -399,10 +424,8 @@ class MetroplexSocket extends Singleton {
      * Returns true if the message's payload has the payload type given and has a sequence
      * number higher than seqNum
      */
-    _messagePayloadHasLargerSeqNum(message, payloadType, seqNum) {
-        return (message.payload[payloadType] &&
-            message.payload[payloadType][SEQ_NUM_ATT_NAME] &&
-            message.payload[payloadType][SEQ_NUM_ATT_NAME] > seqNum);
+    _messagePayloadHasLargerSeqNum(message, seqNum) {
+        return message.payload && message.payload.seq_num && message.payload.seq_num > seqNum;
     }
     /**
      * removes messages from the retry queue that are smaller than the
@@ -410,8 +433,7 @@ class MetroplexSocket extends Singleton {
      */
     _clearRetryQueue(seqNum) {
         this.latestReceivedSeqNumStoredTime = new Date();
-        const newQueue = this.retryMessageQueue.filter(message => this._messagePayloadHasLargerSeqNum(message, PAGE_VISIT_PART_ATT_NAME, seqNum) ||
-            this._messagePayloadHasLargerSeqNum(message, PAGE_VISIT_VID_FRAG_ATT_NAME, seqNum));
+        const newQueue = this.retryMessageQueue.filter(message => this._messagePayloadHasLargerSeqNum(message, seqNum));
         this.retryMessageQueue = createSlidingArrayOfSize(MAX_RETRY_MSG_Q_SIZE, newQueue);
     }
     /** will resend everything that is in the retry queue */
@@ -438,13 +460,12 @@ class MetroplexSocket extends Singleton {
                 }
             }
             // removing all the messages with a blocked type from the retry queue
-            this.retryMessageQueue = this.retryMessageQueue.filter(message => !(message.type in this.metroplexTypeLock));
+            this.retryMessageQueue = this.retryMessageQueue.filter(message => !this.metroplexTypeLock[message.type]);
             // 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);
+                yield this.sendSocketMessage({ [type]: payload });
                 this.previousMessageType = type;
             }
         });
@@ -455,12 +476,6 @@ class MetroplexSocket extends Singleton {
             this._sendUnconfirmedMessages(true);
         }, METROPLEX_RETRY_FREQUENCY);
     }
-    /** sets up events that will trigger the event queue to be emptied */
-    _setupOffloadEvents() {
-        // when the page hides we try getting all the events
-        // and empty the event and retry queue.
-        addSafeEventListener(window, 'pagehide', () => this._handleUnload(), false);
-    }
     /**
      * will handle the final moments of a page being active. It
      * will try to empty both the queues with beacons.
@@ -488,26 +503,29 @@ class MetroplexSocket extends Singleton {
      */
     postFullPageVisit(maxMessageSize) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             if (this.retryMessageQueue.length === 0) {
                 return;
             }
             // debug counters
             const postInfo = [];
             const numDropped = {
-                [VIDEO_METROPLEX_TYPE]: 0,
-                [PV_METROPLEX_TYPE]: 0,
+                pvvf: 0,
+                pvp: 0,
+                pvh: 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,
+                pvi: yield this.getPageInformation(),
+                pvp: [],
+                pvvf: [],
+                pvh: [],
+                vpnum: this.connectionCount,
             };
-            currentCompletePv[PAGE_VISIT_INFORMATION_ATT_NAME][IS_LAST_ATT_NAME] = true;
+            currentCompletePv.pvi.last = true;
             const pageInfo = yield this.getPageInformation();
             this.retryMessageQueue.forEach(msg => {
+                var _a, _b, _c;
                 // can't use two variables types in obj deconstruction
                 // eslint-disable-next-line  prefer-const
                 let { type, payload } = msg;
@@ -522,81 +540,84 @@ class MetroplexSocket extends Singleton {
                 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},`;
+                    let postInfoMessage = `Vid: ${currentCompletePv.pvvf.length}`;
+                    postInfoMessage += ` PV: ${currentCompletePv.pvp.length}`;
+                    postInfoMessage += ` HTTP: ${(_a = currentCompletePv.pvh) === null || _a === void 0 ? void 0 : _a.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],
+                        pvi: pageInfo,
+                        pvp: [],
+                        pvvf: [],
+                        pvh: [],
+                        vpnum: currentCompletePv.vpnum,
                     };
-                    currentCompletePv[PAGE_VISIT_INFORMATION_ATT_NAME][IS_LAST_ATT_NAME] =
-                        true;
+                    currentCompletePv.pvi.last = 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]);
+                switch (msg.type) {
+                    case WebsocketMessageType.PageVisitVideoFile:
+                        currentCompletePv.pvvf.push(msg.payload);
                         break;
-                    case PV_METROPLEX_TYPE:
-                        currentCompletePv[PAGE_VISIT_PART_ATT_NAME].push(payload[PAGE_VISIT_PART_ATT_NAME]);
+                    case WebsocketMessageType.PageVisitPart:
+                        currentCompletePv.pvp.push(msg.payload);
                         break;
-                    case HTTP_DATA_METROPLEX_TYPE:
-                        currentCompletePv[PAGE_VISIT_HTTP_DATA_ATT_NAME].push(payload[PAGE_VISIT_HTTP_DATA_ATT_NAME]);
+                    case WebsocketMessageType.PageVisitHttp:
+                        (_c = (_b = currentCompletePv.pvh) === null || _b === void 0 ? void 0 : _b.push) === null || _c === void 0 ? void 0 : _c.call(_b, msg.payload);
                         break;
                 }
             });
-            this.postMessage(currentCompletePv);
+            yield 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},`;
+                let postInfoMessage = `Vid: ${currentCompletePv.pvvf.length}`;
+                postInfoMessage += ` PV: ${currentCompletePv.pvp.length}`;
+                postInfoMessage += ` HTTP: ${(_a = currentCompletePv.pvh) === null || _a === void 0 ? void 0 : _a.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}`;
+                const message = {
+                    msg: `POST Full PV complete`,
+                    postsCount: postInfo.length,
+                    postsInfo: stringifyJSON(postInfo),
+                    retryMessageQueueSize: this.retryMessageQueue.length,
+                };
                 // Num drops
-                if (numDropped[VIDEO_METROPLEX_TYPE] > 0) {
-                    message += `, Video parts dropped: ${numDropped[VIDEO_METROPLEX_TYPE]}`;
+                if (numDropped.pvvf > 0) {
+                    message.videoPartsDropped = numDropped.pvvf;
                 }
-                if (numDropped[PV_METROPLEX_TYPE] > 0) {
-                    message += `, Page visit parts dropped: ${numDropped[PV_METROPLEX_TYPE]}`;
+                if (numDropped.pvp > 0) {
+                    message.pvpPartsDropped = numDropped.pvp;
                 }
-                if (numDropped[HTTP_DATA_METROPLEX_TYPE] > 0) {
-                    message += `, HTTP data parts dropped: ${numDropped[HTTP_DATA_METROPLEX_TYPE]}`;
+                if (numDropped.pvh > 0) {
+                    message.httpPartsDropped = numDropped.pvh;
                 }
                 // Sequence info
-                message += `, Sequence Info: Latest ${this.messageSequenceNum}`;
-                message += ` Ack'd ${this.latestReceivedSeqNumStoredTime} ${this.latestReceivedSeqNumber}`;
+                message.sequenceInfo = {
+                    Latest: this.messageSequenceNum,
+                    acked: {
+                        latestReceivedSeqNumStoredTime: this.latestReceivedSeqNumStoredTime,
+                        latestReceivedSeqNumber: 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);
+                ClientConfig.getInstance().postInternalError(message, clientDisabled, SEVERITY.warn);
             }
         });
     }
-    /**
-     * will send a message to metroplex via a post request that will outlive the current page
-     */
+    /** will send a message to metroplex via a post request that will outlive the current page */
     postMessage(msg) {
         return __awaiter(this, void 0, void 0, function* () {
             const updatedMsg = msg;
+            updatedMsg.vpnum || (updatedMsg.vpnum = 0);
             // ensure a unique video part number each call
-            updatedMsg[VIDEO_PART_COUNT_ATT_NAME] += 1;
+            updatedMsg.vpnum += 1;
             // we send the remainder elements
             unwrapNoibuWrapped(fetch)(this.postURL, {
                 method: 'POST',
@@ -615,18 +636,16 @@ class MetroplexSocket extends Singleton {
      * is active and returns true. If inactive the session and socket are closed
      * and this method returns false.
      */
-    _sendSocketMessage(payload) {
+    sendSocketMessage(payload) {
         return __awaiter(this, void 0, void 0, function* () {
-            noibuLog('_sendSocketMessage');
+            noibuLog('sendSocketMessage');
             const closeIfInactive = yield this.closeIfInactive();
             if (closeIfInactive) {
-                noibuLog('_sendSocketMessage dropped due to', { closeIfInactive });
+                noibuLog('sendSocketMessage dropped due to', { closeIfInactive });
                 return;
             }
+            noibuLog(`_sendSocketMessage sending: `, payload);
             const payloadJson = stringifyJSON(payload);
-            noibuLog(`_sendSocketMessage sending: ${PAGE_VISIT_VID_FRAG_ATT_NAME in payload
-                ? PAGE_VISIT_VID_FRAG_ATT_NAME
-                : payloadJson}`);
             if (this.socket) {
                 this.socket.send(payloadJson);
             }
@@ -644,7 +663,7 @@ class MetroplexSocket extends Singleton {
                 // 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');
+                yield ClientConfig.getInstance().lockClientUntilNextPage({ msg: 'Session is inactive, locking until next page' });
                 this.close();
                 // post metrics now so we don't include events after going inactive
                 StoredMetrics.getInstance().postMetrics();
@@ -658,29 +677,27 @@ class MetroplexSocket extends Singleton {
     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.initialReferringURL,
-                [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(),
+                br_id: ClientConfig.getInstance().browserId,
+                pv_id: ClientConfig.getInstance().pageVisitId,
+                v: CURRENT_PV_VERSION,
+                seq: yield ClientConfig.getInstance().getPageVisitSeq(),
+                on_url: this.initialURL,
+                ref_url: this.initialReferringURL,
+                start_at: this.sessionTimestamp.toISOString(),
+                conc: this.connectionCount,
+                cv: CURRENT_NOIBUJS_VERSION,
+                last: false,
+                script_id: GET_SCRIPT_ID(),
+                script_inst_id: this.scriptInstanceId,
+                mp_sock_inst_id: this.instanceId,
+                sock_inst_id: this.socketInstanceId,
+                video_recorder: yield getVideoRecorderType(),
             };
         });
     }
-    /**
-     * Try to parse help code response and fire custom event
-     */
+    /** Try to parse help code response and fire custom event */
     _tryProcessHelpCodeResponse(response) {
-        const prefix = `${HELP_CODE_ATT_NAME}:`;
+        const prefix = `${WorkRequestMessageType.HelpCode}:`;
         if (typeof response !== 'string' || !response.startsWith(prefix)) {
             return false;
         }
@@ -692,11 +709,5 @@ class MetroplexSocket extends Singleton {
         return true;
     }
 }
-MetroplexSocket.typeToPayloadPropMap = {
-    [HTTP_DATA_METROPLEX_TYPE]: PAGE_VISIT_HTTP_DATA_ATT_NAME,
-    [META_DATA_METROPLEX_TYPE]: PAGE_VISIT_META_DATA_ATT_NAME,
-    [PV_METROPLEX_TYPE]: PAGE_VISIT_PART_ATT_NAME,
-    [VIDEO_METROPLEX_TYPE]: PAGE_VISIT_VID_FRAG_ATT_NAME,
-};
 
-export { createSlidingArrayOfSize, MetroplexSocket as default };
+export { createSlidingArrayOfSize, MetroplexSocket as default, getVideoRecorderType };