@microsoft/1ds-post-js 3.1.9 → 3.2.0

package/dist-esm/src/PostChannel.js

@@ -1,5 +1,5 @@
 /*
- * 1DS JS SDK POST plugin, 3.1.9
+ * 1DS JS SDK POST plugin, 3.2.0
  * Copyright (c) Microsoft and contributors. All rights reserved.
  * (Microsoft Internal Only)
  */
@@ -9,22 +9,27 @@ import { __extendsFn as __extends } from "@microsoft/applicationinsights-shims";
 * @author Abhilash Panwar (abpanwar); Hector Hernandez (hectorh); Nev Wylie (newylie)
 * @copyright Microsoft 2018-2020
 */
-import { BaseTelemetryPlugin, EventLatency, EventsDiscardedReason, isValueAssigned, addPageUnloadEventListener, addPageHideEventListener, addPageShowEventListener, setProcessTelemetryTimings, isWindowObjectAvailable, arrForEach, LoggingSeverity, _ExtendedInternalMessageId, doPerf, objForEachKey, optimizeObject, isChromium, getWindow, } from "@microsoft/1ds-core-js";
+import { BaseTelemetryPlugin, EventsDiscardedReason, isValueAssigned, setProcessTelemetryTimings, isWindowObjectAvailable, arrForEach, doPerf, objForEachKey, optimizeObject, isChromium, getWindow, isNumber, mergeEvtNamespace, createUniqueNamespace, addPageUnloadEventListener, addPageHideEventListener, addPageShowEventListener, removePageUnloadEventListener, removePageHideEventListener, removePageShowEventListener, _throwInternal } from "@microsoft/1ds-core-js";
 import { RT_PROFILE, NRT_PROFILE, BE_PROFILE, } from "./DataModels";
 import { EventBatch } from "./EventBatch";
-import HttpManager from "./HttpManager";
-import RetryPolicy from "./RetryPolicy";
+import { HttpManager } from "./HttpManager";
+import { retryPolicyGetMillisToBackoffForRetry } from "./RetryPolicy";
 import dynamicProto from "@microsoft/dynamicproto-js";
+import { strMsaDeviceTicket } from "./Constants";
 var FlushCheckTimer = 0.250; // This needs to be in seconds, so this is 250ms
 var MaxNumberEventPerBatch = 500;
 var EventsDroppedAtOneTime = 20;
 var MaxSendAttempts = 6;
+var MaxSyncUnloadSendAttempts = 2; // Assuming 2 based on beforeunload and unload
 var MaxBackoffCount = 4;
 var globalContext = isWindowObjectAvailable ? window : this;
 var MaxConnections = 2;
-var MaxRetries = 1;
+var MaxRequestRetriesBeforeBackoff = 1;
 var strEventsDiscarded = "eventsDiscarded";
 var strOverrideInstrumentationKey = "overrideInstrumentationKey";
+var strMaxEventRetryAttempts = "maxEventRetryAttempts";
+var strMaxUnloadEventRetryAttempts = "maxUnloadEventRetryAttempts";
+var strAddUnloadCb = "addUnloadCb";
 /**
  * Class that manages adding events to inbound queues and batching of events
  * into requests.
@@ -35,7 +40,7 @@ var PostChannel = /** @class */ (function (_super) {
         var _this = _super.call(this) || this;
         _this.identifier = "PostChannel";
         _this.priority = 1011;
-        _this.version = '3.1.9';
+        _this.version = '3.2.0';
         var _config;
         var _isTeardownCalled = false;
         var _flushCallbackQueue = [];
@@ -61,18 +66,12 @@ var PostChannel = /** @class */ (function (_super) {
         var _delayedBatchReason;
         var _optimizeObject = true;
         var _isPageUnloadTriggered = false;
+        var _disableXhrSync = false;
+        var _maxEventSendAttempts = MaxSendAttempts;
+        var _maxUnloadEventSendAttempts = MaxSyncUnloadSendAttempts;
+        var _evtNamespace;
         dynamicProto(PostChannel, _this, function (_self, _base) {
-            _initializeProfiles();
-            _clearQueues();
-            _setAutoLimits();
-            _httpManager = new HttpManager(MaxNumberEventPerBatch, MaxConnections, MaxRetries, {
-                requeue: _requeueEvents,
-                send: _sendingEvent,
-                sent: _eventsSentEvent,
-                drop: _eventsDropped,
-                rspFail: _eventsResponseFail,
-                oth: _otherEvent
-            });
+            _initDefaults();
             // Special internal method to allow the DebugPlugin to hook embedded objects
             _self["_getDbgPlgTargets"] = function () {
                 return [_httpManager];
@@ -81,63 +80,57 @@ var PostChannel = /** @class */ (function (_super) {
                 doPerf(core, function () { return "PostChannel:initialize"; }, function () {
                     var extendedCore = core;
                     _base.initialize(coreConfig, core, extensions);
-                    _self.setInitialized(false);
-                    var ctx = _self._getTelCtx();
-                    coreConfig.extensionConfig[_self.identifier] = coreConfig.extensionConfig[_self.identifier] || {};
-                    _config = ctx.getExtCfg(_self.identifier);
-                    _self._setTimeoutOverride = _config.setTimeoutOverride ? _config.setTimeoutOverride : setTimeout.bind(globalContext);
-                    _self._clearTimeoutOverride = _config.clearTimeoutOverride ? _config.clearTimeoutOverride : clearTimeout.bind(globalContext);
-                    // Only try and use the optimizeObject() if this appears to be a chromium based browser and it has not been explicitly disabled
-                    _optimizeObject = !_config.disableOptimizeObj && isChromium();
-                    var existingGetWParamMethod = extendedCore.getWParam;
-                    extendedCore.getWParam = function () {
-                        var wparam = 0;
-                        if (_config.ignoreMc1Ms0CookieProcessing) {
-                            wparam = wparam | 2;
+                    try {
+                        var hasAddUnloadCb = !!core[strAddUnloadCb];
+                        _evtNamespace = mergeEvtNamespace(createUniqueNamespace(_self.identifier), core.evtNamespace && core.evtNamespace());
+                        var ctx = _self._getTelCtx();
+                        coreConfig.extensionConfig[_self.identifier] = coreConfig.extensionConfig[_self.identifier] || {};
+                        _config = ctx.getExtCfg(_self.identifier);
+                        _self._setTimeoutOverride = _config.setTimeoutOverride ? _config.setTimeoutOverride : setTimeout.bind(globalContext);
+                        _self._clearTimeoutOverride = _config.clearTimeoutOverride ? _config.clearTimeoutOverride : clearTimeout.bind(globalContext);
+                        // Only try and use the optimizeObject() if this appears to be a chromium based browser and it has not been explicitly disabled
+                        _optimizeObject = !_config.disableOptimizeObj && isChromium();
+                        _hookWParam(extendedCore);
+                        if (_config.eventsLimitInMem > 0) {
+                            _queueSizeLimit = _config.eventsLimitInMem;
                         }
-                        return wparam | existingGetWParamMethod();
-                    };
-                    if (_config.eventsLimitInMem > 0) {
-                        _queueSizeLimit = _config.eventsLimitInMem;
-                    }
-                    if (_config.immediateEventLimit > 0) {
-                        _immediateQueueSizeLimit = _config.immediateEventLimit;
-                    }
-                    if (_config.autoFlushEventsLimit > 0) {
-                        _autoFlushEventsLimit = _config.autoFlushEventsLimit;
-                    }
-                    _setAutoLimits();
-                    if (_config.httpXHROverride && _config.httpXHROverride.sendPOST) {
-                        _xhrOverride = _config.httpXHROverride;
-                    }
-                    if (isValueAssigned(coreConfig.anonCookieName)) {
-                        _httpManager.addQueryStringParameter("anoncknm", coreConfig.anonCookieName);
-                    }
-                    _httpManager.sendHook = _config.payloadPreprocessor;
-                    _httpManager.sendListener = _config.payloadListener;
-                    // Override endpointUrl if provided in Post config
-                    var endpointUrl = _config.overrideEndpointUrl ? _config.overrideEndpointUrl : coreConfig.endpointUrl;
-                    _self._notificationManager = coreConfig.extensionConfig.NotificationManager;
-                    _httpManager.initialize(endpointUrl, _self.core, _self, _xhrOverride, _config);
-                    function _handleUnloadEvents(evt) {
-                        var theEvt = evt || getWindow().event; // IE 8 does not pass the event
-                        if (theEvt.type !== "beforeunload") {
-                            // Only set the unload trigger if not beforeunload event as beforeunload can be cancelled while the other events can't
-                            _isPageUnloadTriggered = true;
-                            _httpManager.setUnloading(_isPageUnloadTriggered);
+                        if (_config.immediateEventLimit > 0) {
+                            _immediateQueueSizeLimit = _config.immediateEventLimit;
                         }
-                        _releaseAllQueues(2 /* SendBeacon */, 2 /* Unload */);
+                        if (_config.autoFlushEventsLimit > 0) {
+                            _autoFlushEventsLimit = _config.autoFlushEventsLimit;
+                        }
+                        _disableXhrSync = _config.disableXhrSync;
+                        if (isNumber(_config[strMaxEventRetryAttempts])) {
+                            _maxEventSendAttempts = _config[strMaxEventRetryAttempts];
+                        }
+                        if (isNumber(_config[strMaxUnloadEventRetryAttempts])) {
+                            _maxUnloadEventSendAttempts = _config[strMaxUnloadEventRetryAttempts];
+                        }
+                        _setAutoLimits();
+                        if (_config.httpXHROverride && _config.httpXHROverride.sendPOST) {
+                            _xhrOverride = _config.httpXHROverride;
+                        }
+                        if (isValueAssigned(coreConfig.anonCookieName)) {
+                            _httpManager.addQueryStringParameter("anoncknm", coreConfig.anonCookieName);
+                        }
+                        _httpManager.sendHook = _config.payloadPreprocessor;
+                        _httpManager.sendListener = _config.payloadListener;
+                        // Override endpointUrl if provided in Post config
+                        var endpointUrl = _config.overrideEndpointUrl ? _config.overrideEndpointUrl : coreConfig.endpointUrl;
+                        _self._notificationManager = coreConfig.extensionConfig.NotificationManager;
+                        _httpManager.initialize(endpointUrl, _self.core, _self, _xhrOverride, _config);
+                        var excludePageUnloadEvents = coreConfig.disablePageUnloadEvents || [];
+                        // When running in Web browsers try to send all telemetry if page is unloaded
+                        addPageUnloadEventListener(_handleUnloadEvents, excludePageUnloadEvents, _evtNamespace);
+                        addPageHideEventListener(_handleUnloadEvents, excludePageUnloadEvents, _evtNamespace);
+                        addPageShowEventListener(_handleShowEvents, coreConfig.disablePageShowEvents, _evtNamespace);
+                    }
+                    catch (e) {
+                        // resetting the initialized state because of failure
+                        _self.setInitialized(false);
+                        throw e;
                     }
-                    var excludePageUnloadEvents = coreConfig.disablePageUnloadEvents || [];
-                    // When running in Web browsers try to send all telemetry if page is unloaded
-                    addPageUnloadEventListener(_handleUnloadEvents, excludePageUnloadEvents);
-                    addPageHideEventListener(_handleUnloadEvents, excludePageUnloadEvents);
-                    addPageShowEventListener(function (evt) {
-                        // Handle the page becoming visible again
-                        _isPageUnloadTriggered = false;
-                        _httpManager.setUnloading(_isPageUnloadTriggered);
-                    }, coreConfig.disablePageShowEvents);
-                    _self.setInitialized(true);
                 }, function () { return ({ coreConfig: coreConfig, core: core, extensions: extensions }); });
             };
             _self.processTelemetry = function (ev, itemCtx) {
@@ -172,6 +165,41 @@ var PostChannel = /** @class */ (function (_super) {
                 }
                 _self.processNext(event, itemCtx);
             };
+            _self._doTeardown = function (unloadCtx, unloadState) {
+                _releaseAllQueues(2 /* SendBeacon */, 2 /* Unload */);
+                _isTeardownCalled = true;
+                _httpManager.teardown();
+                removePageUnloadEventListener(null, _evtNamespace);
+                removePageHideEventListener(null, _evtNamespace);
+                removePageShowEventListener(null, _evtNamespace);
+                // Just register to remove all events associated with this namespace
+                _initDefaults();
+            };
+            function _hookWParam(extendedCore) {
+                var existingGetWParamMethod = extendedCore.getWParam;
+                extendedCore.getWParam = function () {
+                    var wparam = 0;
+                    if (_config.ignoreMc1Ms0CookieProcessing) {
+                        wparam = wparam | 2;
+                    }
+                    return wparam | existingGetWParamMethod();
+                };
+            }
+            // Moving event handlers out from the initialize closure so that any local variables can be garbage collected
+            function _handleUnloadEvents(evt) {
+                var theEvt = evt || getWindow().event; // IE 8 does not pass the event
+                if (theEvt.type !== "beforeunload") {
+                    // Only set the unload trigger if not beforeunload event as beforeunload can be cancelled while the other events can't
+                    _isPageUnloadTriggered = true;
+                    _httpManager.setUnloading(_isPageUnloadTriggered);
+                }
+                _releaseAllQueues(2 /* SendBeacon */, 2 /* Unload */);
+            }
+            function _handleShowEvents(evt) {
+                // Handle the page becoming visible again
+                _isPageUnloadTriggered = false;
+                _httpManager.setUnloading(_isPageUnloadTriggered);
+            }
             function _addEventToQueues(event, append) {
                 // If send attempt field is undefined we should set it to 0.
                 if (!event.sendAttempt) {
@@ -179,7 +207,7 @@ var PostChannel = /** @class */ (function (_super) {
                 }
                 // Add default latency
                 if (!event.latency) {
-                    event.latency = EventLatency.Normal;
+                    event.latency = 1 /* Normal */;
                 }
                 // Remove extra AI properties if present
                 if (event.ext && event.ext["trace"]) {
@@ -202,7 +230,7 @@ var PostChannel = /** @class */ (function (_super) {
                     // If the transmission is backed off then do not send synchronous events.
                     // We will convert these events to Real time latency instead.
                     if (_currentBackoffCount || _paused) {
-                        event.latency = EventLatency.RealTime;
+                        event.latency = 3 /* RealTime */;
                         event.sync = false;
                     }
                     else {
@@ -220,7 +248,7 @@ var PostChannel = /** @class */ (function (_super) {
                 var evtLatency = event.latency;
                 var queueSize = _queueSize;
                 var queueLimit = _queueSizeLimit;
-                if (evtLatency === EventLatency.Immediate) {
+                if (evtLatency === 4 /* Immediate */) {
                     queueSize = _immediateQueueSize;
                     queueLimit = _immediateQueueSizeLimit;
                 }
@@ -230,11 +258,11 @@ var PostChannel = /** @class */ (function (_super) {
                     eventDropped = !_addEventToProperQueue(event, append);
                 }
                 else {
-                    var dropLatency = EventLatency.Normal;
+                    var dropLatency = 1 /* Normal */;
                     var dropNumber = EventsDroppedAtOneTime;
-                    if (evtLatency === EventLatency.Immediate) {
+                    if (evtLatency === 4 /* Immediate */) {
                         // Only drop other immediate events as they are not technically sharing the general queue
-                        dropLatency = EventLatency.Immediate;
+                        dropLatency = 4 /* Immediate */;
                         dropNumber = 1;
                     }
                     // Drop old event from lower or equal latency
@@ -256,7 +284,7 @@ var PostChannel = /** @class */ (function (_super) {
                 var doFlush = _queueSize > eventLimit;
                 if (!doFlush && _autoFlushBatchLimit > 0) {
                     // Check the auto flush max batch size
-                    for (var latency = EventLatency.Normal; !doFlush && latency <= EventLatency.RealTime; latency++) {
+                    for (var latency = 1 /* Normal */; !doFlush && latency <= 3 /* RealTime */; latency++) {
                         var batchQueue = _batchQueues[latency];
                         if (batchQueue && batchQueue.batches) {
                             arrForEach(batchQueue.batches, function (theBatch) {
@@ -270,11 +298,6 @@ var PostChannel = /** @class */ (function (_super) {
                 }
                 _performAutoFlush(true, doFlush);
             };
-            _self.teardown = function () {
-                _releaseAllQueues(2 /* SendBeacon */, 2 /* Unload */);
-                _isTeardownCalled = true;
-                _httpManager.teardown();
-            };
             _self.pause = function () {
                 _clearScheduledTimer();
                 _paused = true;
@@ -323,7 +346,7 @@ var PostChannel = /** @class */ (function (_super) {
                     sendReason = sendReason || 1 /* ManualFlush */;
                     if (async) {
                         // Move all queued events to the HttpManager
-                        _queueBatches(EventLatency.Normal, 0 /* Batched */, sendReason);
+                        _queueBatches(1 /* Normal */, 0 /* Batched */, sendReason);
                         // All events (should) have been queue -- lets just make sure the queue counts are correct to avoid queue exhaustion (previous bug #9685112)
                         _resetQueueCounts();
                         if (_flushCallbackTimerId == null) {
@@ -339,7 +362,7 @@ var PostChannel = /** @class */ (function (_super) {
                     }
                     else {
                         // Now cause all queued events to be sent synchronously
-                        _sendEventsForLatencyAndAbove(EventLatency.Normal, 1 /* Synchronous */, sendReason);
+                        _sendEventsForLatencyAndAbove(1 /* Normal */, 1 /* Synchronous */, sendReason);
                         if (callback !== null && callback !== undefined) {
                             callback();
                         }
@@ -347,7 +370,7 @@ var PostChannel = /** @class */ (function (_super) {
                 }
             };
             _self.setMsaAuthTicket = function (ticket) {
-                _httpManager.addHeader("AuthMsaDeviceTicket", ticket);
+                _httpManager.addHeader(strMsaDeviceTicket, ticket);
             };
             _self.hasEvents = _hasEvents;
             _self._setTransmitProfile = function (profileName) {
@@ -389,7 +412,7 @@ var PostChannel = /** @class */ (function (_super) {
                         _immediateTimerId = _createTimer(function () {
                             _immediateTimerId = null;
                             // Only try to send direct events
-                            _sendEventsForLatencyAndAbove(EventLatency.Immediate, 0 /* Batched */, 1 /* NormalSchedule */);
+                            _sendEventsForLatencyAndAbove(4 /* Immediate */, 0 /* Batched */, 1 /* NormalSchedule */);
                             _scheduleTimer();
                         }, immediateTimeOut);
                     }
@@ -400,7 +423,7 @@ var PostChannel = /** @class */ (function (_super) {
                     if (_hasEvents()) {
                         _scheduledTimerId = _createTimer(function () {
                             _scheduledTimerId = null;
-                            _sendEventsForLatencyAndAbove(_timerCount === 0 ? EventLatency.RealTime : EventLatency.Normal, 0 /* Batched */, 1 /* NormalSchedule */);
+                            _sendEventsForLatencyAndAbove(_timerCount === 0 ? 3 /* RealTime */ : 1 /* Normal */, 0 /* Batched */, 1 /* NormalSchedule */);
                             // Increment the count for next cycle
                             _timerCount++;
                             _timerCount %= 2;
@@ -426,6 +449,47 @@ var PostChannel = /** @class */ (function (_super) {
                     _scheduleTimer();
                 }
             };
+            function _initDefaults() {
+                _config = null;
+                _isTeardownCalled = false;
+                _flushCallbackQueue = [];
+                _flushCallbackTimerId = null;
+                _paused = false;
+                _immediateQueueSize = 0;
+                _immediateQueueSizeLimit = 500;
+                _queueSize = 0;
+                _queueSizeLimit = 10000;
+                _profiles = {};
+                _currentProfile = RT_PROFILE;
+                _scheduledTimerId = null;
+                _immediateTimerId = null;
+                _currentBackoffCount = 0;
+                _timerCount = 0;
+                _xhrOverride = null;
+                _batchQueues = {};
+                _autoFlushEventsLimit = undefined;
+                // either MaxBatchSize * (1+ Max Connections) or _queueLimit / 6 (where 3 latency Queues [normal, realtime, cost deferred] * 2 [allow half full -- allow for retry])
+                _autoFlushBatchLimit = 0;
+                _delayedBatchSendLatency = -1;
+                _delayedBatchReason = null;
+                _optimizeObject = true;
+                _isPageUnloadTriggered = false;
+                _disableXhrSync = false;
+                _maxEventSendAttempts = MaxSendAttempts;
+                _maxUnloadEventSendAttempts = MaxSyncUnloadSendAttempts;
+                _evtNamespace = null;
+                _httpManager = new HttpManager(MaxNumberEventPerBatch, MaxConnections, MaxRequestRetriesBeforeBackoff, {
+                    requeue: _requeueEvents,
+                    send: _sendingEvent,
+                    sent: _eventsSentEvent,
+                    drop: _eventsDropped,
+                    rspFail: _eventsResponseFail,
+                    oth: _otherEvent
+                });
+                _initializeProfiles();
+                _clearQueues();
+                _setAutoLimits();
+            }
             function _createTimer(theTimerFunc, timeOut) {
                 // If the transmission is backed off make the timer at least 1 sec to allow for back off.
                 if (timeOut === 0 && _currentBackoffCount) {
@@ -433,7 +497,7 @@ var PostChannel = /** @class */ (function (_super) {
                 }
                 var timerMultiplier = 1000;
                 if (_currentBackoffCount) {
-                    timerMultiplier = RetryPolicy.getMillisToBackoffForRetry(_currentBackoffCount - 1);
+                    timerMultiplier = retryPolicyGetMillisToBackoffForRetry(_currentBackoffCount - 1);
                 }
                 return _self._setTimeoutOverride(theTimerFunc, timeOut * timerMultiplier);
             }
@@ -454,7 +518,7 @@ var PostChannel = /** @class */ (function (_super) {
                 }
                 if (!_paused) {
                     // Queue all the remaining requests to be sent. The requests will be sent using HTML5 Beacons if they are available.
-                    _sendEventsForLatencyAndAbove(EventLatency.Normal, sendType, sendReason);
+                    _sendEventsForLatencyAndAbove(1 /* Normal */, sendType, sendReason);
                 }
             }
             /**
@@ -463,19 +527,19 @@ var PostChannel = /** @class */ (function (_super) {
              * after flush are stored separately till we flush the current events.
              */
             function _clearQueues() {
-                _batchQueues[EventLatency.Immediate] = {
+                _batchQueues[4 /* Immediate */] = {
                     batches: [],
                     iKeyMap: {}
                 };
-                _batchQueues[EventLatency.RealTime] = {
+                _batchQueues[3 /* RealTime */] = {
                     batches: [],
                     iKeyMap: {}
                 };
-                _batchQueues[EventLatency.CostDeferred] = {
+                _batchQueues[2 /* CostDeferred */] = {
                     batches: [],
                     iKeyMap: {}
                 };
-                _batchQueues[EventLatency.Normal] = {
+                _batchQueues[1 /* Normal */] = {
                     batches: [],
                     iKeyMap: {}
                 };
@@ -483,7 +547,7 @@ var PostChannel = /** @class */ (function (_super) {
             function _getEventBatch(iKey, latency, create) {
                 var batchQueue = _batchQueues[latency];
                 if (!batchQueue) {
-                    latency = EventLatency.Normal;
+                    latency = 1 /* Normal */;
                     batchQueue = _batchQueues[latency];
                 }
                 var eventBatch = batchQueue.iKeyMap[iKey];
@@ -514,8 +578,8 @@ var PostChannel = /** @class */ (function (_super) {
                 }
                 var latency = event.latency;
                 var eventBatch = _getEventBatch(event.iKey, latency, true);
-                if (eventBatch.addEvents([event], append)) {
-                    if (latency !== EventLatency.Immediate) {
+                if (eventBatch.addEvent(event)) {
+                    if (latency !== 4 /* Immediate */) {
                         _queueSize++;
                         // Check for auto flushing based on total events in the queue, but not for requeued or retry events
                         if (append && event.sendAttempt === 0) {
@@ -539,7 +603,7 @@ var PostChannel = /** @class */ (function (_super) {
                         var droppedEvents = eventBatch.split(0, dropNumber);
                         var droppedCount = droppedEvents.count();
                         if (droppedCount > 0) {
-                            if (currentLatency === EventLatency.Immediate) {
+                            if (currentLatency === 4 /* Immediate */) {
                                 _immediateQueueSize -= droppedCount;
                             }
                             else {
@@ -566,7 +630,7 @@ var PostChannel = /** @class */ (function (_super) {
                     var batchQueue = _batchQueues[latency];
                     if (batchQueue && batchQueue.batches) {
                         arrForEach(batchQueue.batches, function (theBatch) {
-                            if (latency === EventLatency.Immediate) {
+                            if (latency === 4 /* Immediate */) {
                                 immediateQueue += theBatch.count();
                             }
                             else {
@@ -575,7 +639,7 @@ var PostChannel = /** @class */ (function (_super) {
                         });
                     }
                 };
-                for (var latency = EventLatency.Normal; latency <= EventLatency.Immediate; latency++) {
+                for (var latency = 1 /* Normal */; latency <= 4 /* Immediate */; latency++) {
                     _loop_1(latency);
                 }
                 _queueSize = normalQueue;
@@ -590,7 +654,7 @@ var PostChannel = /** @class */ (function (_super) {
                 if (!isAsync || _httpManager.canSendRequest()) {
                     doPerf(_self.core, function () { return "PostChannel._queueBatches"; }, function () {
                         var droppedEvents = [];
-                        var latencyToProcess = EventLatency.Immediate;
+                        var latencyToProcess = 4 /* Immediate */;
                         while (latencyToProcess >= latency) {
                             var batchQueue = _batchQueues[latencyToProcess];
                             if (batchQueue && batchQueue.batches && batchQueue.batches.length > 0) {
@@ -603,7 +667,7 @@ var PostChannel = /** @class */ (function (_super) {
                                     else {
                                         eventsQueued = eventsQueued || (theBatch && theBatch.count() > 0);
                                     }
-                                    if (latencyToProcess === EventLatency.Immediate) {
+                                    if (latencyToProcess === 4 /* Immediate */) {
                                         _immediateQueueSize -= theBatch.count();
                                     }
                                     else {
@@ -640,7 +704,7 @@ var PostChannel = /** @class */ (function (_super) {
              */
             function _flushImpl(callback, sendReason) {
                 // Add any additional queued events and cause all queued events to be sent asynchronously
-                _sendEventsForLatencyAndAbove(EventLatency.Normal, 0 /* Batched */, sendReason);
+                _sendEventsForLatencyAndAbove(1 /* Normal */, 0 /* Batched */, sendReason);
                 _waitForIdleManager(function () {
                     // Only called AFTER the httpManager does not have any outstanding requests
                     if (callback) {
@@ -691,16 +755,21 @@ var PostChannel = /** @class */ (function (_super) {
              */
             function _requeueEvents(batches, reason) {
                 var droppedEvents = [];
+                var maxSendAttempts = _maxEventSendAttempts;
+                if (_isPageUnloadTriggered) {
+                    // If a page unlaod has been triggered reduce the number of times we try to "retry"
+                    maxSendAttempts = _maxUnloadEventSendAttempts;
+                }
                 arrForEach(batches, function (theBatch) {
                     if (theBatch && theBatch.count() > 0) {
                         arrForEach(theBatch.events(), function (theEvent) {
                             if (theEvent) {
                                 // Check if the request being added back is for a sync event in which case mark it no longer a sync event
                                 if (theEvent.sync) {
-                                    theEvent.latency = EventLatency.Immediate;
+                                    theEvent.latency = 4 /* Immediate */;
                                     theEvent.sync = false;
                                 }
-                                if (theEvent.sendAttempt < MaxSendAttempts) {
+                                if (theEvent.sendAttempt < maxSendAttempts) {
                                     // Reset the event timings
                                     setProcessTelemetryTimings(theEvent, _self.identifier);
                                     _addEventToQueues(theEvent, false);
@@ -728,7 +797,7 @@ var PostChannel = /** @class */ (function (_super) {
                         notifyFunc.apply(manager, theArgs);
                     }
                     catch (e) {
-                        _self.diagLog().throwInternal(LoggingSeverity.CRITICAL, _ExtendedInternalMessageId.NotificationException, evtName + " notification failed: " + e);
+                        _throwInternal(_self.diagLog(), 1 /* CRITICAL */, 74 /* NotificationException */, evtName + " notification failed: " + e);
                     }
                 }
             }
@@ -804,7 +873,6 @@ var PostChannel = /** @class */ (function (_super) {
 // Removed Stub for PostChannel.prototype.initialize.
 // Removed Stub for PostChannel.prototype.processTelemetry.
 // Removed Stub for PostChannel.prototype.setEventQueueLimits.
-// Removed Stub for PostChannel.prototype.teardown.
 // Removed Stub for PostChannel.prototype.pause.
 // Removed Stub for PostChannel.prototype.resume.
 // Removed Stub for PostChannel.prototype.addResponseHandler.