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

package/dist-esm/src/PostChannel.js

@@ -1,5 +1,5 @@
 /*
- * 1DS JS SDK POST plugin, 3.2.1
+ * 1DS JS SDK POST plugin, 3.2.4
  * Copyright (c) Microsoft and contributors. All rights reserved.
  * (Microsoft Internal Only)
  */
@@ -9,20 +9,20 @@ import { __extendsFn as __extends } from "@microsoft/applicationinsights-shims";
 * @author Abhilash Panwar (abpanwar); Hector Hernandez (hectorh); Nev Wylie (newylie)
 * @copyright Microsoft 2018-2020
 */
-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 dynamicProto from "@microsoft/dynamicproto-js";
+import { BaseTelemetryPlugin, EventsDiscardedReason, _throwInternal, addPageHideEventListener, addPageShowEventListener, addPageUnloadEventListener, arrForEach, createUniqueNamespace, doPerf, getWindow, isChromium, isNumber, isValueAssigned, mergeEvtNamespace, objDefineAccessors, objForEachKey, optimizeObject, removePageHideEventListener, removePageShowEventListener, removePageUnloadEventListener, setProcessTelemetryTimings } from "@microsoft/1ds-core-js";
+import { BE_PROFILE, NRT_PROFILE, RT_PROFILE } from "./DataModels";
 import { EventBatch } from "./EventBatch";
 import { HttpManager } from "./HttpManager";
+import { STR_MSA_DEVICE_TICKET, STR_TRACE, STR_USER } from "./InternalConstants";
 import { retryPolicyGetMillisToBackoffForRetry } from "./RetryPolicy";
-import dynamicProto from "@microsoft/dynamicproto-js";
-import { strMsaDeviceTicket } from "./Constants";
+import { createTimeoutWrapper } from "./TimeoutOverrideWrapper";
 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 MaxRequestRetriesBeforeBackoff = 1;
 var strEventsDiscarded = "eventsDiscarded";
@@ -40,7 +40,7 @@ var PostChannel = /** @class */ (function (_super) {
         var _this = _super.call(this) || this;
         _this.identifier = "PostChannel";
         _this.priority = 1011;
-        _this.version = '3.2.1';
+        _this.version = '3.2.4';
         var _config;
         var _isTeardownCalled = false;
         var _flushCallbackQueue = [];
@@ -66,10 +66,10 @@ var PostChannel = /** @class */ (function (_super) {
         var _delayedBatchReason;
         var _optimizeObject = true;
         var _isPageUnloadTriggered = false;
-        var _disableXhrSync = false;
         var _maxEventSendAttempts = MaxSendAttempts;
         var _maxUnloadEventSendAttempts = MaxSyncUnloadSendAttempts;
         var _evtNamespace;
+        var _timeoutWrapper;
         dynamicProto(PostChannel, _this, function (_self, _base) {
             _initDefaults();
             // Special internal method to allow the DebugPlugin to hook embedded objects
@@ -86,8 +86,7 @@ var PostChannel = /** @class */ (function (_super) {
                         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);
+                        _timeoutWrapper = createTimeoutWrapper(_config.setTimeoutOverride, _config.clearTimeoutOverride);
                         // 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);
@@ -100,7 +99,6 @@ var PostChannel = /** @class */ (function (_super) {
                         if (_config.autoFlushEventsLimit > 0) {
                             _autoFlushEventsLimit = _config.autoFlushEventsLimit;
                         }
-                        _disableXhrSync = _config.disableXhrSync;
                         if (isNumber(_config[strMaxEventRetryAttempts])) {
                             _maxEventSendAttempts = _config[strMaxEventRetryAttempts];
                         }
@@ -157,7 +155,7 @@ var PostChannel = /** @class */ (function (_super) {
                     _addEventToQueues(event, true);
                     if (_isPageUnloadTriggered) {
                         // Unload event has been received so we need to try and flush new events
-                        _releaseAllQueues(2 /* SendBeacon */, 2 /* Unload */);
+                        _releaseAllQueues(2 /* EventSendType.SendBeacon */, 2 /* SendRequestReason.Unload */);
                     }
                     else {
                         _scheduleTimer();
@@ -166,7 +164,7 @@ var PostChannel = /** @class */ (function (_super) {
                 _self.processNext(event, itemCtx);
             };
             _self._doTeardown = function (unloadCtx, unloadState) {
-                _releaseAllQueues(2 /* SendBeacon */, 2 /* Unload */);
+                _releaseAllQueues(2 /* EventSendType.SendBeacon */, 2 /* SendRequestReason.Unload */);
                 _isTeardownCalled = true;
                 _httpManager.teardown();
                 removePageUnloadEventListener(null, _evtNamespace);
@@ -193,7 +191,7 @@ var PostChannel = /** @class */ (function (_super) {
                     _isPageUnloadTriggered = true;
                     _httpManager.setUnloading(_isPageUnloadTriggered);
                 }
-                _releaseAllQueues(2 /* SendBeacon */, 2 /* Unload */);
+                _releaseAllQueues(2 /* EventSendType.SendBeacon */, 2 /* SendRequestReason.Unload */);
             }
             function _handleShowEvents(evt) {
                 // Handle the page becoming visible again
@@ -207,17 +205,18 @@ var PostChannel = /** @class */ (function (_super) {
                 }
                 // Add default latency
                 if (!event.latency) {
-                    event.latency = 1 /* Normal */;
+                    event.latency = 1 /* EventLatencyValue.Normal */;
                 }
                 // Remove extra AI properties if present
-                if (event.ext && event.ext["trace"]) {
-                    delete (event.ext["trace"]);
+                if (event.ext && event.ext[STR_TRACE]) {
+                    delete (event.ext[STR_TRACE]);
                 }
-                if (event.ext && event.ext["user"] && event.ext["user"]["id"]) {
-                    delete (event.ext["user"]["id"]);
+                if (event.ext && event.ext[STR_USER] && event.ext[STR_USER]["id"]) {
+                    delete (event.ext[STR_USER]["id"]);
                 }
                 // v8 performance optimization for iterating over the keys
                 if (_optimizeObject) {
+                    setProcessTelemetryTimings;
                     event.ext = optimizeObject(event.ext);
                     if (event.baseData) {
                         event.baseData = optimizeObject(event.baseData);
@@ -230,7 +229,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 = 3 /* RealTime */;
+                        event.latency = 3 /* EventLatencyValue.RealTime */;
                         event.sync = false;
                     }
                     else {
@@ -240,7 +239,7 @@ var PostChannel = /** @class */ (function (_super) {
                             if (_optimizeObject) {
                                 event = optimizeObject(event);
                             }
-                            _httpManager.sendSynchronousBatch(EventBatch.create(event.iKey, [event]), event.sync === true ? 1 /* Synchronous */ : event.sync, 3 /* SyncEvent */);
+                            _httpManager.sendSynchronousBatch(EventBatch.create(event.iKey, [event]), event.sync === true ? 1 /* EventSendType.Synchronous */ : event.sync, 3 /* SendRequestReason.SyncEvent */);
                             return;
                         }
                     }
@@ -248,7 +247,7 @@ var PostChannel = /** @class */ (function (_super) {
                 var evtLatency = event.latency;
                 var queueSize = _queueSize;
                 var queueLimit = _queueSizeLimit;
-                if (evtLatency === 4 /* Immediate */) {
+                if (evtLatency === 4 /* EventLatencyValue.Immediate */) {
                     queueSize = _immediateQueueSize;
                     queueLimit = _immediateQueueSizeLimit;
                 }
@@ -258,11 +257,11 @@ var PostChannel = /** @class */ (function (_super) {
                     eventDropped = !_addEventToProperQueue(event, append);
                 }
                 else {
-                    var dropLatency = 1 /* Normal */;
+                    var dropLatency = 1 /* EventLatencyValue.Normal */;
                     var dropNumber = EventsDroppedAtOneTime;
-                    if (evtLatency === 4 /* Immediate */) {
+                    if (evtLatency === 4 /* EventLatencyValue.Immediate */) {
                         // Only drop other immediate events as they are not technically sharing the general queue
-                        dropLatency = 4 /* Immediate */;
+                        dropLatency = 4 /* EventLatencyValue.Immediate */;
                         dropNumber = 1;
                     }
                     // Drop old event from lower or equal latency
@@ -284,7 +283,7 @@ var PostChannel = /** @class */ (function (_super) {
                 var doFlush = _queueSize > eventLimit;
                 if (!doFlush && _autoFlushBatchLimit > 0) {
                     // Check the auto flush max batch size
-                    for (var latency = 1 /* Normal */; !doFlush && latency <= 3 /* RealTime */; latency++) {
+                    for (var latency = 1 /* EventLatencyValue.Normal */; !doFlush && latency <= 3 /* EventLatencyValue.RealTime */; latency++) {
                         var batchQueue = _batchQueues[latency];
                         if (batchQueue && batchQueue.batches) {
                             arrForEach(batchQueue.batches, function (theBatch) {
@@ -341,16 +340,15 @@ var PostChannel = /** @class */ (function (_super) {
             _self.flush = function (async, callback, sendReason) {
                 if (async === void 0) { async = true; }
                 if (!_paused) {
-                    // Clear the normal schedule timer as we are going to try and flush ASAP
-                    _clearScheduledTimer();
-                    sendReason = sendReason || 1 /* ManualFlush */;
+                    sendReason = sendReason || 1 /* SendRequestReason.ManualFlush */;
                     if (async) {
-                        // Move all queued events to the HttpManager
-                        _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) {
+                            // Clear the normal schedule timer as we are going to try and flush ASAP
+                            _clearScheduledTimer();
+                            // Move all queued events to the HttpManager so that we don't discard new events (Auto flush scenario)
+                            _queueBatches(1 /* EventLatencyValue.Normal */, 0 /* EventSendType.Batched */, sendReason);
                             _flushCallbackTimerId = _createTimer(function () {
+                                _flushCallbackTimerId = null;
                                 _flushImpl(callback, sendReason);
                             }, 0);
                         }
@@ -361,16 +359,22 @@ var PostChannel = /** @class */ (function (_super) {
                         }
                     }
                     else {
+                        // Clear the normal schedule timer as we are going to try and flush ASAP
+                        var cleared = _clearScheduledTimer();
                         // Now cause all queued events to be sent synchronously
-                        _sendEventsForLatencyAndAbove(1 /* Normal */, 1 /* Synchronous */, sendReason);
+                        _sendEventsForLatencyAndAbove(1 /* EventLatencyValue.Normal */, 1 /* EventSendType.Synchronous */, sendReason);
                         if (callback !== null && callback !== undefined) {
                             callback();
                         }
+                        if (cleared) {
+                            // restart the normal event timer if it was cleared
+                            _scheduleTimer();
+                        }
                     }
                 }
             };
             _self.setMsaAuthTicket = function (ticket) {
-                _httpManager.addHeader(strMsaDeviceTicket, ticket);
+                _httpManager.addHeader(STR_MSA_DEVICE_TICKET, ticket);
             };
             _self.hasEvents = _hasEvents;
             _self._setTransmitProfile = function (profileName) {
@@ -401,8 +405,8 @@ var PostChannel = /** @class */ (function (_super) {
             function _scheduleTimer() {
                 // If we had previously attempted to send requests, but the http manager didn't have any idle connections then the requests where delayed
                 // so try and requeue then again now
-                if (_delayedBatchSendLatency >= 0 && _queueBatches(_delayedBatchSendLatency, 0 /* Batched */, _delayedBatchReason)) {
-                    _httpManager.sendQueuedRequests(0 /* Batched */, _delayedBatchReason);
+                if (_delayedBatchSendLatency >= 0 && _queueBatches(_delayedBatchSendLatency, 0 /* EventSendType.Batched */, _delayedBatchReason)) {
+                    _httpManager.sendQueuedRequests(0 /* EventSendType.Batched */, _delayedBatchReason);
                 }
                 if (_immediateQueueSize > 0 && !_immediateTimerId && !_paused) {
                     // During initialization _profiles enforce that the direct [2] is less than real time [1] timer value
@@ -412,7 +416,7 @@ var PostChannel = /** @class */ (function (_super) {
                         _immediateTimerId = _createTimer(function () {
                             _immediateTimerId = null;
                             // Only try to send direct events
-                            _sendEventsForLatencyAndAbove(4 /* Immediate */, 0 /* Batched */, 1 /* NormalSchedule */);
+                            _sendEventsForLatencyAndAbove(4 /* EventLatencyValue.Immediate */, 0 /* EventSendType.Batched */, 1 /* SendRequestReason.NormalSchedule */);
                             _scheduleTimer();
                         }, immediateTimeOut);
                     }
@@ -423,7 +427,7 @@ var PostChannel = /** @class */ (function (_super) {
                     if (_hasEvents()) {
                         _scheduledTimerId = _createTimer(function () {
                             _scheduledTimerId = null;
-                            _sendEventsForLatencyAndAbove(_timerCount === 0 ? 3 /* RealTime */ : 1 /* Normal */, 0 /* Batched */, 1 /* NormalSchedule */);
+                            _sendEventsForLatencyAndAbove(_timerCount === 0 ? 3 /* EventLatencyValue.RealTime */ : 1 /* EventLatencyValue.Normal */, 0 /* EventSendType.Batched */, 1 /* SendRequestReason.NormalSchedule */);
                             // Increment the count for next cycle
                             _timerCount++;
                             _timerCount %= 2;
@@ -474,10 +478,10 @@ var PostChannel = /** @class */ (function (_super) {
                 _delayedBatchReason = null;
                 _optimizeObject = true;
                 _isPageUnloadTriggered = false;
-                _disableXhrSync = false;
                 _maxEventSendAttempts = MaxSendAttempts;
                 _maxUnloadEventSendAttempts = MaxSyncUnloadSendAttempts;
                 _evtNamespace = null;
+                _timeoutWrapper = createTimeoutWrapper();
                 _httpManager = new HttpManager(MaxNumberEventPerBatch, MaxConnections, MaxRequestRetriesBeforeBackoff, {
                     requeue: _requeueEvents,
                     send: _sendingEvent,
@@ -485,7 +489,7 @@ var PostChannel = /** @class */ (function (_super) {
                     drop: _eventsDropped,
                     rspFail: _eventsResponseFail,
                     oth: _otherEvent
-                });
+                }, _timeoutWrapper);
                 _initializeProfiles();
                 _clearQueues();
                 _setAutoLimits();
@@ -499,26 +503,28 @@ var PostChannel = /** @class */ (function (_super) {
                 if (_currentBackoffCount) {
                     timerMultiplier = retryPolicyGetMillisToBackoffForRetry(_currentBackoffCount - 1);
                 }
-                return _self._setTimeoutOverride(theTimerFunc, timeOut * timerMultiplier);
+                return _timeoutWrapper.set(theTimerFunc, timeOut * timerMultiplier);
             }
             function _clearScheduledTimer() {
                 if (_scheduledTimerId !== null) {
-                    _self._clearTimeoutOverride(_scheduledTimerId);
+                    _timeoutWrapper.clear(_scheduledTimerId);
                     _scheduledTimerId = null;
                     _timerCount = 0;
+                    return true;
                 }
+                return false;
             }
             // Try to send all queued events using beacons if available
             function _releaseAllQueues(sendType, sendReason) {
                 _clearScheduledTimer();
                 // Cancel all flush callbacks
                 if (_flushCallbackTimerId) {
-                    _self._clearTimeoutOverride(_flushCallbackTimerId);
+                    _timeoutWrapper.clear(_flushCallbackTimerId);
                     _flushCallbackTimerId = null;
                 }
                 if (!_paused) {
                     // Queue all the remaining requests to be sent. The requests will be sent using HTML5 Beacons if they are available.
-                    _sendEventsForLatencyAndAbove(1 /* Normal */, sendType, sendReason);
+                    _sendEventsForLatencyAndAbove(1 /* EventLatencyValue.Normal */, sendType, sendReason);
                 }
             }
             /**
@@ -527,19 +533,19 @@ var PostChannel = /** @class */ (function (_super) {
              * after flush are stored separately till we flush the current events.
              */
             function _clearQueues() {
-                _batchQueues[4 /* Immediate */] = {
+                _batchQueues[4 /* EventLatencyValue.Immediate */] = {
                     batches: [],
                     iKeyMap: {}
                 };
-                _batchQueues[3 /* RealTime */] = {
+                _batchQueues[3 /* EventLatencyValue.RealTime */] = {
                     batches: [],
                     iKeyMap: {}
                 };
-                _batchQueues[2 /* CostDeferred */] = {
+                _batchQueues[2 /* EventLatencyValue.CostDeferred */] = {
                     batches: [],
                     iKeyMap: {}
                 };
-                _batchQueues[1 /* Normal */] = {
+                _batchQueues[1 /* EventLatencyValue.Normal */] = {
                     batches: [],
                     iKeyMap: {}
                 };
@@ -547,7 +553,7 @@ var PostChannel = /** @class */ (function (_super) {
             function _getEventBatch(iKey, latency, create) {
                 var batchQueue = _batchQueues[latency];
                 if (!batchQueue) {
-                    latency = 1 /* Normal */;
+                    latency = 1 /* EventLatencyValue.Normal */;
                     batchQueue = _batchQueues[latency];
                 }
                 var eventBatch = batchQueue.iKeyMap[iKey];
@@ -567,7 +573,7 @@ var PostChannel = /** @class */ (function (_super) {
                     }
                     if (doFlush && _flushCallbackTimerId == null) {
                         // Auto flush the queue
-                        _self.flush(isAsync, null, 20 /* MaxQueuedEvents */);
+                        _self.flush(isAsync, null, 20 /* SendRequestReason.MaxQueuedEvents */);
                     }
                 }
             }
@@ -579,7 +585,7 @@ var PostChannel = /** @class */ (function (_super) {
                 var latency = event.latency;
                 var eventBatch = _getEventBatch(event.iKey, latency, true);
                 if (eventBatch.addEvent(event)) {
-                    if (latency !== 4 /* Immediate */) {
+                    if (latency !== 4 /* EventLatencyValue.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) {
@@ -603,7 +609,7 @@ var PostChannel = /** @class */ (function (_super) {
                         var droppedEvents = eventBatch.split(0, dropNumber);
                         var droppedCount = droppedEvents.count();
                         if (droppedCount > 0) {
-                            if (currentLatency === 4 /* Immediate */) {
+                            if (currentLatency === 4 /* EventLatencyValue.Immediate */) {
                                 _immediateQueueSize -= droppedCount;
                             }
                             else {
@@ -630,7 +636,7 @@ var PostChannel = /** @class */ (function (_super) {
                     var batchQueue = _batchQueues[latency];
                     if (batchQueue && batchQueue.batches) {
                         arrForEach(batchQueue.batches, function (theBatch) {
-                            if (latency === 4 /* Immediate */) {
+                            if (latency === 4 /* EventLatencyValue.Immediate */) {
                                 immediateQueue += theBatch.count();
                             }
                             else {
@@ -639,7 +645,7 @@ var PostChannel = /** @class */ (function (_super) {
                         });
                     }
                 };
-                for (var latency = 1 /* Normal */; latency <= 4 /* Immediate */; latency++) {
+                for (var latency = 1 /* EventLatencyValue.Normal */; latency <= 4 /* EventLatencyValue.Immediate */; latency++) {
                     _loop_1(latency);
                 }
                 _queueSize = normalQueue;
@@ -647,14 +653,14 @@ var PostChannel = /** @class */ (function (_super) {
             }
             function _queueBatches(latency, sendType, sendReason) {
                 var eventsQueued = false;
-                var isAsync = sendType === 0 /* Batched */;
+                var isAsync = sendType === 0 /* EventSendType.Batched */;
                 // Only queue batches (to the HttpManager) if this is a sync request or the httpManager has an idle connection
                 // Thus keeping the events within the PostChannel until the HttpManager has a connection available
                 // This is so we can drop "old" events if the queue is getting full because we can't successfully send events
                 if (!isAsync || _httpManager.canSendRequest()) {
                     doPerf(_self.core, function () { return "PostChannel._queueBatches"; }, function () {
                         var droppedEvents = [];
-                        var latencyToProcess = 4 /* Immediate */;
+                        var latencyToProcess = 4 /* EventLatencyValue.Immediate */;
                         while (latencyToProcess >= latency) {
                             var batchQueue = _batchQueues[latencyToProcess];
                             if (batchQueue && batchQueue.batches && batchQueue.batches.length > 0) {
@@ -667,7 +673,7 @@ var PostChannel = /** @class */ (function (_super) {
                                     else {
                                         eventsQueued = eventsQueued || (theBatch && theBatch.count() > 0);
                                     }
-                                    if (latencyToProcess === 4 /* Immediate */) {
+                                    if (latencyToProcess === 4 /* EventLatencyValue.Immediate */) {
                                         _immediateQueueSize -= theBatch.count();
                                     }
                                     else {
@@ -686,7 +692,7 @@ var PostChannel = /** @class */ (function (_super) {
                         if (eventsQueued && _delayedBatchSendLatency >= latency) {
                             // We have queued events at the same level as the delayed values so clear the setting
                             _delayedBatchSendLatency = -1;
-                            _delayedBatchReason = 0 /* Undefined */;
+                            _delayedBatchReason = 0 /* SendRequestReason.Undefined */;
                         }
                     }, function () { return ({ latency: latency, sendType: sendType, sendReason: sendReason }); }, !isAsync);
                 }
@@ -704,22 +710,25 @@ var PostChannel = /** @class */ (function (_super) {
              */
             function _flushImpl(callback, sendReason) {
                 // Add any additional queued events and cause all queued events to be sent asynchronously
-                _sendEventsForLatencyAndAbove(1 /* Normal */, 0 /* Batched */, sendReason);
+                _sendEventsForLatencyAndAbove(1 /* EventLatencyValue.Normal */, 0 /* 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();
                 _waitForIdleManager(function () {
                     // Only called AFTER the httpManager does not have any outstanding requests
                     if (callback) {
                         callback();
                     }
                     if (_flushCallbackQueue.length > 0) {
-                        _flushCallbackTimerId = _createTimer(function () { return _flushImpl(_flushCallbackQueue.shift(), sendReason); }, 0);
+                        _flushCallbackTimerId = _createTimer(function () {
+                            _flushCallbackTimerId = null;
+                            _flushImpl(_flushCallbackQueue.shift(), sendReason);
+                        }, 0);
                     }
                     else {
                         // No more flush requests
                         _flushCallbackTimerId = null;
-                        if (_hasEvents()) {
-                            // We still have events, so restart the normal timer schedule
-                            _scheduleTimer();
-                        }
+                        // Restart the normal timer schedule
+                        _scheduleTimer();
                     }
                 });
             }
@@ -729,6 +738,7 @@ var PostChannel = /** @class */ (function (_super) {
                 }
                 else {
                     _flushCallbackTimerId = _createTimer(function () {
+                        _flushCallbackTimerId = null;
                         _waitForIdleManager(callback);
                     }, FlushCheckTimer);
                 }
@@ -766,7 +776,7 @@ var PostChannel = /** @class */ (function (_super) {
                             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 = 4 /* Immediate */;
+                                    theEvent.latency = 4 /* EventLatencyValue.Immediate */;
                                     theEvent.sync = false;
                                 }
                                 if (theEvent.sendAttempt < maxSendAttempts) {
@@ -786,7 +796,7 @@ var PostChannel = /** @class */ (function (_super) {
                 }
                 if (_isPageUnloadTriggered) {
                     // Unload event has been received so we need to try and flush new events
-                    _releaseAllQueues(2 /* SendBeacon */, 2 /* Unload */);
+                    _releaseAllQueues(2 /* EventSendType.SendBeacon */, 2 /* SendRequestReason.Unload */);
                 }
             }
             function _callNotification(evtName, theArgs) {
@@ -797,7 +807,7 @@ var PostChannel = /** @class */ (function (_super) {
                         notifyFunc.apply(manager, theArgs);
                     }
                     catch (e) {
-                        _throwInternal(_self.diagLog(), 1 /* CRITICAL */, 74 /* NotificationException */, evtName + " notification failed: " + e);
+                        _throwInternal(_self.diagLog(), 1 /* eLoggingSeverity.CRITICAL */, 74 /* _eInternalMessageId.NotificationException */, evtName + " notification failed: " + e);
                     }
                 }
             }
@@ -829,9 +839,9 @@ var PostChannel = /** @class */ (function (_super) {
              */
             function _sendingEvent(batches, reason, isSyncRequest) {
                 if (batches && batches.length > 0) {
-                    _callNotification("eventsSendRequest", [(reason >= 1000 /* SendingUndefined */ && reason <= 1999 /* SendingEventMax */ ?
-                            reason - 1000 /* SendingUndefined */ :
-                            0 /* Undefined */), isSyncRequest !== true]);
+                    _callNotification("eventsSendRequest", [(reason >= 1000 /* EventBatchNotificationReason.SendingUndefined */ && reason <= 1999 /* EventBatchNotificationReason.SendingEventMax */ ?
+                            reason - 1000 /* EventBatchNotificationReason.SendingUndefined */ :
+                            0 /* SendRequestReason.Undefined */), isSyncRequest !== true]);
                 }
             }
             /**
@@ -845,8 +855,8 @@ var PostChannel = /** @class */ (function (_super) {
                 _scheduleTimer();
             }
             function _eventsDropped(batches, reason) {
-                _notifyBatchEvents(strEventsDiscarded, batches, (reason >= 8000 /* EventsDropped */ && reason <= 8999 /* EventsDroppedMax */ ?
-                    reason - 8000 /* EventsDropped */ :
+                _notifyBatchEvents(strEventsDiscarded, batches, (reason >= 8000 /* EventBatchNotificationReason.EventsDropped */ && reason <= 8999 /* EventBatchNotificationReason.EventsDroppedMax */ ?
+                    reason - 8000 /* EventBatchNotificationReason.EventsDropped */ :
                     EventsDiscardedReason.Unknown));
             }
             function _eventsResponseFail(batches) {
@@ -867,6 +877,15 @@ var PostChannel = /** @class */ (function (_super) {
                     _autoFlushBatchLimit = 0;
                 }
             }
+            // Provided for backward compatibility they are not "expected" to be in current use but they are public
+            objDefineAccessors(_self, "_setTimeoutOverride", function () { return _timeoutWrapper.set; }, function (value) {
+                // Recreate the timeout wrapper
+                _timeoutWrapper = createTimeoutWrapper(value, _timeoutWrapper.clear);
+            });
+            objDefineAccessors(_self, "_clearTimeoutOverride", function () { return _timeoutWrapper.clear; }, function (value) {
+                // Recreate the timeout wrapper
+                _timeoutWrapper = createTimeoutWrapper(_timeoutWrapper.set, value);
+            });
         });
         return _this;
     }
@@ -883,6 +902,11 @@ var PostChannel = /** @class */ (function (_super) {
 // Removed Stub for PostChannel.prototype._setTransmitProfile.
 // Removed Stub for PostChannel.prototype._backOffTransmission.
 // Removed Stub for PostChannel.prototype._clearBackOff.
+    // This is a workaround for an IE8 bug when using dynamicProto() with classes that don't have any
+    // non-dynamic functions or static properties/functions when using uglify-js to minify the resulting code.
+    // this will be removed when ES3 support is dropped.
+    PostChannel.__ieDyn=1;
+
     return PostChannel;
 }(BaseTelemetryPlugin));
 export default PostChannel;