@microsoft/1ds-post-js 3.1.10 → 3.2.1

package/src/PostChannel.ts

@@ -5,10 +5,15 @@
 */
 import {
     BaseTelemetryPlugin, IChannelControls, IExtendedConfiguration, IExtendedAppInsightsCore,
-    EventLatency, NotificationManager, EventsDiscardedReason, IPlugin, ITelemetryItem,
-    IAppInsightsCore, isValueAssigned, addPageUnloadEventListener, addPageHideEventListener, addPageShowEventListener, setProcessTelemetryTimings,
-    isWindowObjectAvailable, IProcessTelemetryContext, SendRequestReason, arrForEach,
-    LoggingSeverity, _ExtendedInternalMessageId, doPerf, objForEachKey, optimizeObject, isChromium, getWindow, EventSendType, addEventHandler, getDocument,
+    EventLatencyValue, NotificationManager, EventsDiscardedReason, IPlugin, ITelemetryItem,
+    IAppInsightsCore, isValueAssigned, setProcessTelemetryTimings, isWindowObjectAvailable,
+    IProcessTelemetryContext, SendRequestReason, arrForEach, eLoggingSeverity, _eExtendedInternalMessageId,
+    doPerf, objForEachKey, optimizeObject, isChromium, getWindow, EventSendType, isNumber, mergeEvtNamespace,
+    createUniqueNamespace, IProcessTelemetryUnloadContext, ITelemetryUnloadState,
+    addPageUnloadEventListener, addPageHideEventListener, addPageShowEventListener,
+    removePageUnloadEventListener, removePageHideEventListener, removePageShowEventListener,
+    _throwInternal,
+    _eInternalMessageId
 } from "@microsoft/1ds-core-js";
 import {
     IChannelConfiguration, RT_PROFILE, NRT_PROFILE, IPostChannel,
@@ -17,7 +22,7 @@ import {
 } from "./DataModels";
 import { EventBatch } from "./EventBatch";
 import { HttpManager } from "./HttpManager";
-import RetryPolicy from "./RetryPolicy";
+import { retryPolicyGetMillisToBackoffForRetry } from "./RetryPolicy";
 import dynamicProto from "@microsoft/dynamicproto-js";
 import { strMsaDeviceTicket } from "./Constants";
 
@@ -25,14 +30,20 @@ const FlushCheckTimer = 0.250;          // This needs to be in seconds, so this
 const MaxNumberEventPerBatch = 500;
 const EventsDroppedAtOneTime = 20;
 const MaxSendAttempts = 6;
+const MaxSyncUnloadSendAttempts = 2;        // Assuming 2 based on beforeunload and unload
 const MaxBackoffCount = 4;
 const globalContext = isWindowObjectAvailable ? window : this;
 const MaxConnections = 2;
-const MaxRetries = 1;
+const MaxRequestRetriesBeforeBackoff = 1;
 
 const strEventsDiscarded = "eventsDiscarded";
 const strOverrideInstrumentationKey = "overrideInstrumentationKey";
 
+const strMaxEventRetryAttempts = "maxEventRetryAttempts";
+const strMaxUnloadEventRetryAttempts = "maxUnloadEventRetryAttempts";
+
+const strAddUnloadCb = "addUnloadCb";
+
 interface IPostChannelBatchQueue {
     /**
      * This is the actual queue of event batches
@@ -86,20 +97,13 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
         let _delayedBatchReason: SendRequestReason;
         let _optimizeObject: boolean = true;
         let _isPageUnloadTriggered = false;
+        let _disableXhrSync = false;
+        let _maxEventSendAttempts: number = MaxSendAttempts;
+        let _maxUnloadEventSendAttempts: number = MaxSyncUnloadSendAttempts;
+        let _evtNamespace: string | string[];
 
         dynamicProto(PostChannel, this, (_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"] = () => {
@@ -110,76 +114,69 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
                 doPerf(core, () => "PostChannel:initialize", () => {
                     let extendedCore = core as IExtendedAppInsightsCore;
                     _base.initialize(coreConfig, core, extensions);
-                    _self.setInitialized(false);
-                    let 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 = () => {
-                        var wparam = 0;
-                        if (_config.ignoreMc1Ms0CookieProcessing) {
-                            wparam = wparam | 2;
+                    try {
+                        let hasAddUnloadCb = !!core[strAddUnloadCb];
+                        _evtNamespace = mergeEvtNamespace(createUniqueNamespace(_self.identifier), core.evtNamespace && core.evtNamespace());
+
+                        let 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
-                    let endpointUrl = _config.overrideEndpointUrl ? _config.overrideEndpointUrl : coreConfig.endpointUrl;
-                    _self._notificationManager = coreConfig.extensionConfig.NotificationManager;
-                    _httpManager.initialize(endpointUrl, _self.core as IExtendedAppInsightsCore, _self, _xhrOverride, _config);
-
-                    function _handleUnloadEvents(evt: any) {
-                        let 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(EventSendType.SendBeacon, SendRequestReason.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
+                        let endpointUrl = _config.overrideEndpointUrl ? _config.overrideEndpointUrl : coreConfig.endpointUrl;
+                        _self._notificationManager = coreConfig.extensionConfig.NotificationManager;
+                        _httpManager.initialize(endpointUrl, _self.core as IExtendedAppInsightsCore, _self, _xhrOverride, _config);
+    
+                        let 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;
                     }
-
-                    let excludePageUnloadEvents = coreConfig.disablePageUnloadEvents || [];
-
-                    // When running in Web browsers try to send all telemetry if page is unloaded
-                    addPageUnloadEventListener(_handleUnloadEvents, excludePageUnloadEvents);
-                    addPageHideEventListener(_handleUnloadEvents, excludePageUnloadEvents);
-                    addPageShowEventListener((evt) => {
-                        // Handle the page becoming visible again
-                        _isPageUnloadTriggered = false;
-                        _httpManager.setUnloading(_isPageUnloadTriggered);
-                    }, coreConfig.disablePageShowEvents);
-
-                    _self.setInitialized(true);
                 }, () => ({ coreConfig, core, extensions }));
             };
 
@@ -222,6 +219,48 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
                 _self.processNext(event, itemCtx);
             };
 
+            _self._doTeardown = (unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState) => {
+                _releaseAllQueues(EventSendType.SendBeacon, SendRequestReason.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: IExtendedAppInsightsCore) {
+                var existingGetWParamMethod = extendedCore.getWParam;
+                extendedCore.getWParam = () => {
+                    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: any) {
+                let 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(EventSendType.SendBeacon, SendRequestReason.Unload);
+            }
+
+            function _handleShowEvents(evt: any) {
+                // Handle the page becoming visible again
+                _isPageUnloadTriggered = false;
+                _httpManager.setUnloading(_isPageUnloadTriggered);
+            }
+
             function _addEventToQueues(event: IPostTransmissionTelemetryItem, append: boolean) {
                 // If send attempt field is undefined we should set it to 0.
                 if (!event.sendAttempt) {
@@ -229,7 +268,7 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
                 }
                 // Add default latency
                 if (!event.latency) {
-                    event.latency = EventLatency.Normal;
+                    event.latency = EventLatencyValue.Normal;
                 }
 
                 // Remove extra AI properties if present
@@ -255,7 +294,7 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
                     // 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 = EventLatencyValue.RealTime;
                         event.sync = false;
                     } else {
                         // Log the event synchronously
@@ -277,7 +316,7 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
                 let evtLatency = event.latency;
                 let queueSize = _queueSize;
                 let queueLimit = _queueSizeLimit;
-                if (evtLatency === EventLatency.Immediate) {
+                if (evtLatency === EventLatencyValue.Immediate) {
                     queueSize = _immediateQueueSize;
                     queueLimit = _immediateQueueSizeLimit;
                 }
@@ -287,11 +326,11 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
                 if (queueSize < queueLimit) {
                     eventDropped = !_addEventToProperQueue(event, append);
                 } else {
-                    let dropLatency = EventLatency.Normal;
+                    let dropLatency = EventLatencyValue.Normal;
                     let dropNumber = EventsDroppedAtOneTime;
-                    if (evtLatency === EventLatency.Immediate) {
+                    if (evtLatency === EventLatencyValue.Immediate) {
                         // Only drop other immediate events as they are not technically sharing the general queue
-                        dropLatency = EventLatency.Immediate;
+                        dropLatency = EventLatencyValue.Immediate;
                         dropNumber = 1;
                     }
 
@@ -318,7 +357,7 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
 
                 if (!doFlush && _autoFlushBatchLimit > 0) {
                     // Check the auto flush max batch size
-                    for (let latency = EventLatency.Normal; !doFlush && latency <= EventLatency.RealTime; latency++) {
+                    for (let latency = EventLatencyValue.Normal; !doFlush && latency <= EventLatencyValue.RealTime; latency++) {
                         let batchQueue: IPostChannelBatchQueue = _batchQueues[latency];
                         if (batchQueue && batchQueue.batches) {
                             arrForEach(batchQueue.batches, (theBatch) => {
@@ -334,12 +373,6 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
                 _performAutoFlush(true, doFlush);
             };
 
-            _self.teardown = () => {
-                _releaseAllQueues(EventSendType.SendBeacon, SendRequestReason.Unload);
-                _isTeardownCalled = true;
-                _httpManager.teardown();
-            };
-
             _self.pause = () => {
                 _clearScheduledTimer();
                 _paused = true;
@@ -395,7 +428,7 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
 
                     if (async) {
                         // Move all queued events to the HttpManager
-                        _queueBatches(EventLatency.Normal, EventSendType.Batched, sendReason);
+                        _queueBatches(EventLatencyValue.Normal, EventSendType.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();
@@ -411,7 +444,7 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
                         }
                     } else {
                         // Now cause all queued events to be sent synchronously
-                        _sendEventsForLatencyAndAbove(EventLatency.Normal, EventSendType.Synchronous, sendReason);
+                        _sendEventsForLatencyAndAbove(EventLatencyValue.Normal, EventSendType.Synchronous, sendReason);
 
                         if (callback !== null && callback !== undefined) {
                             callback();
@@ -471,7 +504,7 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
                         _immediateTimerId = _createTimer(() => {
                             _immediateTimerId = null;
                             // Only try to send direct events
-                            _sendEventsForLatencyAndAbove(EventLatency.Immediate, EventSendType.Batched, SendRequestReason.NormalSchedule);
+                            _sendEventsForLatencyAndAbove(EventLatencyValue.Immediate, EventSendType.Batched, SendRequestReason.NormalSchedule);
                             _scheduleTimer();
                         }, immediateTimeOut);
                     }
@@ -483,7 +516,7 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
                     if (_hasEvents()) {
                         _scheduledTimerId = _createTimer(() => {
                             _scheduledTimerId = null;
-                            _sendEventsForLatencyAndAbove(_timerCount === 0 ? EventLatency.RealTime : EventLatency.Normal, EventSendType.Batched, SendRequestReason.NormalSchedule);
+                            _sendEventsForLatencyAndAbove(_timerCount === 0 ? EventLatencyValue.RealTime : EventLatencyValue.Normal, EventSendType.Batched, SendRequestReason.NormalSchedule);
 
                             // Increment the count for next cycle
                             _timerCount++;
@@ -513,6 +546,50 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
                 }
             };
 
+            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: () => void, timeOut: number): any {
                 // If the transmission is backed off make the timer at least 1 sec to allow for back off.
                 if (timeOut === 0 && _currentBackoffCount) {
@@ -521,7 +598,7 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
 
                 let timerMultiplier = 1000;
                 if (_currentBackoffCount) {
-                    timerMultiplier = RetryPolicy.getMillisToBackoffForRetry(_currentBackoffCount - 1);
+                    timerMultiplier = retryPolicyGetMillisToBackoffForRetry(_currentBackoffCount - 1);
                 }
 
                 return _self._setTimeoutOverride(theTimerFunc, timeOut * timerMultiplier);
@@ -546,7 +623,7 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
 
                 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(EventLatencyValue.Normal, sendType, sendReason);
                 }
             }
 
@@ -556,19 +633,19 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
              * after flush are stored separately till we flush the current events.
              */
             function _clearQueues() {
-                _batchQueues[EventLatency.Immediate] = {
+                _batchQueues[EventLatencyValue.Immediate] = {
                     batches: [],
                     iKeyMap: {}
                 };
-                _batchQueues[EventLatency.RealTime] = {
+                _batchQueues[EventLatencyValue.RealTime] = {
                     batches: [],
                     iKeyMap: {}
                 };
-                _batchQueues[EventLatency.CostDeferred] = {
+                _batchQueues[EventLatencyValue.CostDeferred] = {
                     batches: [],
                     iKeyMap: {}
                 };
-                _batchQueues[EventLatency.Normal] = {
+                _batchQueues[EventLatencyValue.Normal] = {
                     batches: [],
                     iKeyMap: {}
                 };
@@ -577,7 +654,7 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
             function _getEventBatch(iKey: string, latency: number, create: boolean) {
                 let batchQueue: IPostChannelBatchQueue = _batchQueues[latency];
                 if (!batchQueue) {
-                    latency = EventLatency.Normal;
+                    latency = EventLatencyValue.Normal;
                     batchQueue = _batchQueues[latency];
                 }
 
@@ -615,7 +692,7 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
                 const latency = event.latency;
                 let eventBatch = _getEventBatch(event.iKey, latency, true);
                 if (eventBatch.addEvent(event)) {
-                    if (latency !== EventLatency.Immediate) {
+                    if (latency !== EventLatencyValue.Immediate) {
                         _queueSize++;
 
                         // Check for auto flushing based on total events in the queue, but not for requeued or retry events
@@ -642,7 +719,7 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
                         let droppedEvents = eventBatch.split(0, dropNumber);
                         let droppedCount = droppedEvents.count();
                         if (droppedCount > 0) {
-                            if (currentLatency === EventLatency.Immediate) {
+                            if (currentLatency === EventLatencyValue.Immediate) {
                                 _immediateQueueSize -= droppedCount;
                             } else {
                                 _queueSize -= droppedCount;
@@ -669,11 +746,11 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
             function _resetQueueCounts() {
                 let immediateQueue = 0;
                 let normalQueue = 0;
-                for (let latency = EventLatency.Normal; latency <= EventLatency.Immediate; latency++) {
+                for (let latency = EventLatencyValue.Normal; latency <= EventLatencyValue.Immediate; latency++) {
                     let batchQueue: IPostChannelBatchQueue = _batchQueues[latency];
                     if (batchQueue && batchQueue.batches) {
                         arrForEach(batchQueue.batches, (theBatch) => {
-                            if (latency === EventLatency.Immediate) {
+                            if (latency === EventLatencyValue.Immediate) {
                                 immediateQueue += theBatch.count();
                             } else {
                                 normalQueue += theBatch.count();
@@ -696,7 +773,7 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
                 if (!isAsync || _httpManager.canSendRequest()) {
                     doPerf(_self.core, () => "PostChannel._queueBatches", () => {
                         let droppedEvents = [];
-                        let latencyToProcess = EventLatency.Immediate;
+                        let latencyToProcess = EventLatencyValue.Immediate;
                         while (latencyToProcess >= latency) {
                             let batchQueue: IPostChannelBatchQueue = _batchQueues[latencyToProcess];
                             if (batchQueue && batchQueue.batches && batchQueue.batches.length > 0) {
@@ -709,7 +786,7 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
                                         eventsQueued = eventsQueued || (theBatch && theBatch.count() > 0);
                                     }
 
-                                    if (latencyToProcess === EventLatency.Immediate) {
+                                    if (latencyToProcess === EventLatencyValue.Immediate) {
                                         _immediateQueueSize -= theBatch.count();
                                     } else {
                                         _queueSize -= theBatch.count();
@@ -750,7 +827,7 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
              */
             function _flushImpl(callback: () => void, sendReason: SendRequestReason) {
                 // Add any additional queued events and cause all queued events to be sent asynchronously
-                _sendEventsForLatencyAndAbove(EventLatency.Normal, EventSendType.Batched, sendReason);
+                _sendEventsForLatencyAndAbove(EventLatencyValue.Normal, EventSendType.Batched, sendReason);
 
                 _waitForIdleManager(() => {
                     // Only called AFTER the httpManager does not have any outstanding requests
@@ -805,6 +882,11 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
              */
             function _requeueEvents(batches: EventBatch[], reason?: number) {
                 let droppedEvents: IPostTransmissionTelemetryItem[] = [];
+                let maxSendAttempts = _maxEventSendAttempts;
+                if (_isPageUnloadTriggered) {
+                    // If a page unlaod has been triggered reduce the number of times we try to "retry"
+                    maxSendAttempts = _maxUnloadEventSendAttempts;
+                }
 
                 arrForEach(batches, (theBatch) => {
                     if (theBatch && theBatch.count() > 0) {
@@ -813,11 +895,11 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
                             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 = EventLatencyValue.Immediate;
                                     theEvent.sync = false;
                                 }
 
-                                if (theEvent.sendAttempt < MaxSendAttempts) {
+                                if (theEvent.sendAttempt < maxSendAttempts) {
                                     // Reset the event timings
                                     setProcessTelemetryTimings(theEvent, _self.identifier);
                                     _addEventToQueues(theEvent, false);
@@ -846,8 +928,9 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
                     try {
                         notifyFunc.apply(manager, theArgs);
                     } catch (e) {
-                        _self.diagLog().throwInternal(LoggingSeverity.CRITICAL,
-                            _ExtendedInternalMessageId.NotificationException,
+                        _throwInternal(_self.diagLog(),
+                            eLoggingSeverity.CRITICAL,
+                            _eInternalMessageId.NotificationException,
                             evtName + " notification failed: " + e);
                     }
                 }
@@ -959,13 +1042,6 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
         // @DynamicProtoStub - DO NOT add any code as this will be removed during packaging
     }
 
-    /**
-     * Batch all current events in the queues and send them.
-     */
-    public teardown() {
-        // @DynamicProtoStub - DO NOT add any code as this will be removed during packaging
-    }
-
     /**
      * Pause the transmission of any requests
      */

package/src/RetryPolicy.ts

@@ -9,43 +9,38 @@ const BaseBackoff = 3000;
 const MaxBackoff = 600000;
 
 /**
-* Class for retry policy.
-*/
-export default class RetryPolicy {
-    /**
-     * Determine if the request should be retried for the given status code.
-     * The below expression reads that we should only retry for:
-     *      - HttpStatusCodes that are smaller than 300.
-     *      - HttpStatusCodes greater or equal to 500 (except for 501-NotImplement
-     *        and 505-HttpVersionNotSupport).
-     *      - HttpStatusCode 408-RequestTimeout.
-     *      - HttpStatusCode 429.
-     * This is based on Microsoft.WindowsAzure.Storage.RetryPolicies.ExponentialRetry class
-     * @param httpStatusCode - The status code returned for the request.
-     * @returns True if request should be retried, false otherwise.
-     */
-    public static shouldRetryForStatus(httpStatusCode: number): boolean {
-        /* tslint:disable:triple-equals */
-        // Disabling triple-equals rule to avoid httpOverrides from failing because they are returning a string value
-        return !((httpStatusCode >= 300 && httpStatusCode < 500 && httpStatusCode != 408 && httpStatusCode != 429)
-            || (httpStatusCode == 501)
-            || (httpStatusCode == 505));
-        /* tslint:enable:triple-equals */
-    }
+ * Determine if the request should be retried for the given status code.
+ * The below expression reads that we should only retry for:
+ *      - HttpStatusCodes that are smaller than 300.
+ *      - HttpStatusCodes greater or equal to 500 (except for 501-NotImplement
+ *        and 505-HttpVersionNotSupport).
+ *      - HttpStatusCode 408-RequestTimeout.
+ *      - HttpStatusCode 429.
+ * This is based on Microsoft.WindowsAzure.Storage.RetryPolicies.ExponentialRetry class
+ * @param httpStatusCode - The status code returned for the request.
+ * @returns True if request should be retried, false otherwise.
+ */
+export function retryPolicyShouldRetryForStatus(httpStatusCode: number): boolean {
+    /* tslint:disable:triple-equals */
+    // Disabling triple-equals rule to avoid httpOverrides from failing because they are returning a string value
+    return !((httpStatusCode >= 300 && httpStatusCode < 500 && httpStatusCode != 408 && httpStatusCode != 429)
+        || (httpStatusCode == 501)
+        || (httpStatusCode == 505));
+    /* tslint:enable:triple-equals */
+}
 
-    /**
-     * Gets the number of milliseconds to back off before retrying the request. The
-     * back off duration is exponentially scaled based on the number of retries already
-     * done for the request.
-     * @param retriesSoFar - The number of times the request has already been retried.
-     * @returns The back off duration for the request before it can be retried.
-     */
-    public static getMillisToBackoffForRetry(retriesSoFar: number): number {
-        let waitDuration = 0;
-        let minBackoff = BaseBackoff * RandomizationLowerThreshold;
-        let maxBackoff = BaseBackoff * RandomizationUpperThreshold;
-        let randomBackoff = Math.floor(Math.random() * (maxBackoff - minBackoff)) + minBackoff;
-        waitDuration = Math.pow(2, retriesSoFar) * randomBackoff;
-        return Math.min(waitDuration, MaxBackoff);
-    }
+/**
+ * Gets the number of milliseconds to back off before retrying the request. The
+ * back off duration is exponentially scaled based on the number of retries already
+ * done for the request.
+ * @param retriesSoFar - The number of times the request has already been retried.
+ * @returns The back off duration for the request before it can be retried.
+ */
+export function retryPolicyGetMillisToBackoffForRetry(retriesSoFar: number): number {
+    let waitDuration = 0;
+    let minBackoff = BaseBackoff * RandomizationLowerThreshold;
+    let maxBackoff = BaseBackoff * RandomizationUpperThreshold;
+    let randomBackoff = Math.floor(Math.random() * (maxBackoff - minBackoff)) + minBackoff;
+    waitDuration = Math.pow(2, retriesSoFar) * randomBackoff;
+    return Math.min(waitDuration, MaxBackoff);
 }