@microsoft/1ds-post-js 3.2.2 → 3.2.3

package/dist-esm/src/PostChannel.js

@@ -1,5 +1,5 @@
 /*
- * 1DS JS SDK POST plugin, 3.2.2
+ * 1DS JS SDK POST plugin, 3.2.3
  * Copyright (c) Microsoft and contributors. All rights reserved.
  * (Microsoft Internal Only)
  */
@@ -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.2';
+        _this.version = '3.2.3';
         var _config;
         var _isTeardownCalled = false;
         var _flushCallbackQueue = [];
@@ -66,7 +66,6 @@ var PostChannel = /** @class */ (function (_super) {
         var _delayedBatchReason;
         var _optimizeObject = true;
         var _isPageUnloadTriggered = false;
-        var _disableXhrSync = false;
         var _maxEventSendAttempts = MaxSendAttempts;
         var _maxUnloadEventSendAttempts = MaxSyncUnloadSendAttempts;
         var _evtNamespace;
@@ -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,7 +205,7 @@ 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"]) {
@@ -230,7 +228,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 +238,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 +246,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 +256,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 +282,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 +339,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,11 +358,17 @@ 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();
+                        }
                     }
                 }
             };
@@ -401,8 +404,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 +415,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 +426,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,7 +477,6 @@ var PostChannel = /** @class */ (function (_super) {
                 _delayedBatchReason = null;
                 _optimizeObject = true;
                 _isPageUnloadTriggered = false;
-                _disableXhrSync = false;
                 _maxEventSendAttempts = MaxSendAttempts;
                 _maxUnloadEventSendAttempts = MaxSyncUnloadSendAttempts;
                 _evtNamespace = null;
@@ -507,7 +509,9 @@ var PostChannel = /** @class */ (function (_super) {
                     _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) {
@@ -519,7 +523,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(1 /* Normal */, sendType, sendReason);
+                    _sendEventsForLatencyAndAbove(1 /* EventLatencyValue.Normal */, sendType, sendReason);
                 }
             }
             /**
@@ -528,19 +532,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: {}
                 };
@@ -548,7 +552,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];
@@ -568,7 +572,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 */);
                     }
                 }
             }
@@ -580,7 +584,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) {
@@ -604,7 +608,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 {
@@ -631,7 +635,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 {
@@ -640,7 +644,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;
@@ -648,14 +652,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) {
@@ -668,7 +672,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 {
@@ -687,7 +691,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);
                 }
@@ -705,22 +709,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();
                     }
                 });
             }
@@ -730,6 +737,7 @@ var PostChannel = /** @class */ (function (_super) {
                 }
                 else {
                     _flushCallbackTimerId = _createTimer(function () {
+                        _flushCallbackTimerId = null;
                         _waitForIdleManager(callback);
                     }, FlushCheckTimer);
                 }
@@ -767,7 +775,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) {
@@ -787,7 +795,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) {
@@ -798,7 +806,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);
                     }
                 }
             }
@@ -830,9 +838,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]);
                 }
             }
             /**
@@ -846,8 +854,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) {