@microsoft/1ds-post-js 3.2.11 → 4.0.0

package/{dist-esm/src → dist-es5}/PostChannel.js

@@ -1,5 +1,5 @@
 /*
- * 1DS JS SDK POST plugin, 3.2.11
+ * 1DS JS SDK POST plugin, 4.0.0
  * Copyright (c) Microsoft and contributors. All rights reserved.
  * (Microsoft Internal Only)
  */
@@ -10,7 +10,9 @@ import { __extendsFn as __extends } from "@microsoft/applicationinsights-shims";
 * @copyright Microsoft 2018-2020
 */
 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 { BaseTelemetryPlugin, EventsDiscardedReason, _throwInternal, addPageHideEventListener, addPageShowEventListener, addPageUnloadEventListener, arrForEach, createProcessTelemetryContext, createUniqueNamespace, doPerf, getWindow, isChromium, isGreaterThanZero, isNumber, mergeEvtNamespace, objForEachKey, onConfigChange, optimizeObject, proxyFunctions, removePageHideEventListener, removePageShowEventListener, removePageUnloadEventListener, setProcessTelemetryTimings } from "@microsoft/1ds-core-js";
+import { createPromise } from "@nevware21/ts-async";
+import { objDeepFreeze } from "@nevware21/ts-utils";
 import { BE_PROFILE, NRT_PROFILE, RT_PROFILE } from "./DataModels";
 import { EventBatch } from "./EventBatch";
 import { HttpManager } from "./HttpManager";
@@ -25,11 +27,49 @@ var MaxSyncUnloadSendAttempts = 2; // Assuming 2 based on beforeunload and unloa
 var MaxBackoffCount = 4;
 var MaxConnections = 2;
 var MaxRequestRetriesBeforeBackoff = 1;
+var MaxEventsLimitInMem = 10000;
 var strEventsDiscarded = "eventsDiscarded";
-var strOverrideInstrumentationKey = "overrideInstrumentationKey";
-var strMaxEventRetryAttempts = "maxEventRetryAttempts";
-var strMaxUnloadEventRetryAttempts = "maxUnloadEventRetryAttempts";
-var strAddUnloadCb = "addUnloadCb";
+var undefValue = undefined;
+/**
+ * The default settings for the config.
+ * WE MUST include all defaults here to ensure that the config is created with all of the properties
+ * defined as dynamic.
+ */
+var defaultPostChannelConfig = objDeepFreeze({
+    eventsLimitInMem: { isVal: isGreaterThanZero, v: MaxEventsLimitInMem },
+    immediateEventLimit: { isVal: isGreaterThanZero, v: 500 },
+    autoFlushEventsLimit: { isVal: isGreaterThanZero, v: 0 },
+    disableAutoBatchFlushLimit: false,
+    httpXHROverride: { isVal: isOverrideFn, v: undefValue },
+    overrideInstrumentationKey: undefValue,
+    overrideEndpointUrl: undefValue,
+    disableTelemetry: false,
+    ignoreMc1Ms0CookieProcessing: false,
+    setTimeoutOverride: undefValue,
+    clearTimeoutOverride: undefValue,
+    payloadPreprocessor: undefValue,
+    payloadListener: undefValue,
+    disableEventTimings: undefValue,
+    valueSanitizer: undefValue,
+    stringifyObjects: undefValue,
+    enableCompoundKey: undefValue,
+    disableOptimizeObj: false,
+    // disableCacheHeader: undefValue, // See Task #7178858 - Collector requires a change to support this
+    transports: undefValue,
+    unloadTransports: undefValue,
+    useSendBeacon: undefValue,
+    disableFetchKeepAlive: undefValue,
+    avoidOptions: false,
+    xhrTimeout: undefValue,
+    disableXhrSync: undefValue,
+    alwaysUseXhrOverride: false,
+    maxEventRetryAttempts: { isVal: isNumber, v: MaxSendAttempts },
+    maxUnloadEventRetryAttempts: { isVal: isNumber, v: MaxSyncUnloadSendAttempts },
+    addNoResponse: undefValue
+});
+function isOverrideFn(httpXHROverride) {
+    return httpXHROverride && httpXHROverride.sendPOST;
+}
 /**
  * Class that manages adding events to inbound queues and batching of events
  * into requests.
@@ -40,117 +80,100 @@ var PostChannel = /** @class */ (function (_super) {
         var _this = _super.call(this) || this;
         _this.identifier = "PostChannel";
         _this.priority = 1011;
-        _this.version = '3.2.11';
-        var _config;
+        _this.version = '4.0.0';
+        var _postConfig;
         var _isTeardownCalled = false;
         var _flushCallbackQueue = [];
-        var _flushCallbackTimerId = null;
+        var _flushCallbackTimer;
         var _paused = false;
         var _immediateQueueSize = 0;
-        var _immediateQueueSizeLimit = 500;
+        var _immediateQueueSizeLimit;
         var _queueSize = 0;
-        var _queueSizeLimit = 10000;
+        var _queueSizeLimit;
         var _profiles = {};
         var _currentProfile = RT_PROFILE;
-        var _scheduledTimerId = null;
-        var _immediateTimerId = null;
-        var _currentBackoffCount = 0;
-        var _timerCount = 0;
-        var _xhrOverride;
+        var _scheduledTimer;
+        var _immediateTimer;
+        var _currentBackoffCount;
+        var _timerCount;
         var _httpManager;
-        var _batchQueues = {};
+        var _batchQueues;
         var _autoFlushEventsLimit;
         // either MaxBatchSize * (1+ Max Connections) or _queueLimit / 6 (where 3 latency Queues [normal, realtime, cost deferred] * 2 [allow half full -- allow for retry])
         var _autoFlushBatchLimit;
-        var _delayedBatchSendLatency = -1;
+        var _delayedBatchSendLatency;
         var _delayedBatchReason;
-        var _optimizeObject = true;
-        var _isPageUnloadTriggered = false;
-        var _maxEventSendAttempts = MaxSendAttempts;
-        var _maxUnloadEventSendAttempts = MaxSyncUnloadSendAttempts;
+        var _optimizeObject;
+        var _isPageUnloadTriggered;
+        var _maxEventSendAttempts;
+        var _maxUnloadEventSendAttempts;
         var _evtNamespace;
         var _timeoutWrapper;
+        var _ignoreMc1Ms0CookieProcessing;
+        var _disableAutoBatchFlushLimit;
+        var _notificationManager;
+        var _unloadHandlersAdded;
+        var _overrideInstrumentationKey;
+        var _disableTelemetry;
         dynamicProto(PostChannel, _this, function (_self, _base) {
             _initDefaults();
             // Special internal method to allow the DebugPlugin to hook embedded objects
             _self["_getDbgPlgTargets"] = function () {
-                return [_httpManager];
+                return [_httpManager, _postConfig];
             };
-            _self.initialize = function (coreConfig, core, extensions) {
+            _self.initialize = function (theConfig, core, extensions) {
                 doPerf(core, function () { return "PostChannel:initialize"; }, function () {
-                    var extendedCore = core;
-                    _base.initialize(coreConfig, core, extensions);
+                    _base.initialize(theConfig, core, extensions);
+                    _notificationManager = core.getNotifyMgr();
                     try {
-                        var hasAddUnloadCb = !!core[strAddUnloadCb];
                         _evtNamespace = mergeEvtNamespace(createUniqueNamespace(_self.identifier), core.evtNamespace && core.evtNamespace());
-                        var ctx = _self._getTelCtx();
-                        coreConfig.extensionConfig[_self.identifier] = coreConfig.extensionConfig[_self.identifier] || {};
-                        _config = ctx.getExtCfg(_self.identifier);
-                        _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);
-                        if (_config.eventsLimitInMem > 0) {
-                            _queueSizeLimit = _config.eventsLimitInMem;
-                        }
-                        if (_config.immediateEventLimit > 0) {
-                            _immediateQueueSizeLimit = _config.immediateEventLimit;
-                        }
-                        if (_config.autoFlushEventsLimit > 0) {
-                            _autoFlushEventsLimit = _config.autoFlushEventsLimit;
-                        }
-                        if (isNumber(_config[strMaxEventRetryAttempts])) {
-                            _maxEventSendAttempts = _config[strMaxEventRetryAttempts];
-                        }
-                        if (isNumber(_config[strMaxUnloadEventRetryAttempts])) {
-                            _maxUnloadEventSendAttempts = _config[strMaxUnloadEventRetryAttempts];
-                        }
-                        _setAutoLimits();
-                        if (_config.httpXHROverride && _config.httpXHROverride.sendPOST) {
-                            _xhrOverride = _config.httpXHROverride;
-                        }
-                        if (isValueAssigned(coreConfig.anonCookieName)) {
-                            _httpManager.addQueryStringParameter("anoncknm", coreConfig.anonCookieName);
-                        }
-                        _httpManager.sendHook = _config.payloadPreprocessor;
-                        _httpManager.sendListener = _config.payloadListener;
-                        // Override endpointUrl if provided in Post config
-                        var endpointUrl = _config.overrideEndpointUrl ? _config.overrideEndpointUrl : coreConfig.endpointUrl;
-                        _self._notificationManager = core.getNotifyMgr();
-                        _httpManager.initialize(endpointUrl, _self.core, _self, _xhrOverride, _config);
-                        var excludePageUnloadEvents = coreConfig.disablePageUnloadEvents || [];
-                        // When running in Web browsers try to send all telemetry if page is unloaded
-                        addPageUnloadEventListener(_handleUnloadEvents, excludePageUnloadEvents, _evtNamespace);
-                        addPageHideEventListener(_handleUnloadEvents, excludePageUnloadEvents, _evtNamespace);
-                        addPageShowEventListener(_handleShowEvents, coreConfig.disablePageShowEvents, _evtNamespace);
+                        _self._addHook(onConfigChange(theConfig, function (details) {
+                            var coreConfig = details.cfg;
+                            var ctx = createProcessTelemetryContext(null, coreConfig, core);
+                            _postConfig = ctx.getExtCfg(_self.identifier, defaultPostChannelConfig);
+                            _timeoutWrapper = createTimeoutWrapper(_postConfig.setTimeoutOverride, _postConfig.clearTimeoutOverride);
+                            // Only try and use the optimizeObject() if this appears to be a chromium based browser and it has not been explicitly disabled
+                            _optimizeObject = !_postConfig.disableOptimizeObj && isChromium();
+                            _ignoreMc1Ms0CookieProcessing = _postConfig.ignoreMc1Ms0CookieProcessing;
+                            _hookWParam(core); // _hookWParam uses _ignoreMc1Ms0CookieProcessing 
+                            _queueSizeLimit = _postConfig.eventsLimitInMem;
+                            _immediateQueueSizeLimit = _postConfig.immediateEventLimit;
+                            _autoFlushEventsLimit = _postConfig.autoFlushEventsLimit;
+                            _maxEventSendAttempts = _postConfig.maxEventRetryAttempts;
+                            _maxUnloadEventSendAttempts = _postConfig.maxUnloadEventRetryAttempts;
+                            _disableAutoBatchFlushLimit = _postConfig.disableAutoBatchFlushLimit;
+                            _setAutoLimits();
+                            // Override iKey if provided in Post config if provided for during initialization
+                            _overrideInstrumentationKey = _postConfig.overrideInstrumentationKey;
+                            // DisableTelemetry was defined in the config provided during initialization
+                            _disableTelemetry = !!_postConfig.disableTelemetry;
+                            if (_unloadHandlersAdded) {
+                                _removeUnloadHandlers();
+                            }
+                            var excludePageUnloadEvents = coreConfig.disablePageUnloadEvents || [];
+                            // When running in Web browsers try to send all telemetry if page is unloaded
+                            _unloadHandlersAdded = addPageUnloadEventListener(_handleUnloadEvents, excludePageUnloadEvents, _evtNamespace);
+                            _unloadHandlersAdded = addPageHideEventListener(_handleUnloadEvents, excludePageUnloadEvents, _evtNamespace) || _unloadHandlersAdded;
+                            _unloadHandlersAdded = addPageShowEventListener(_handleShowEvents, coreConfig.disablePageShowEvents, _evtNamespace) || _unloadHandlersAdded;
+                        }));
+                        // only initialize the manager once
+                        _httpManager.initialize(theConfig, _self.core, _self);
                     }
                     catch (e) {
                         // resetting the initialized state because of failure
                         _self.setInitialized(false);
                         throw e;
                     }
-                }, function () { return ({ coreConfig: coreConfig, core: core, extensions: extensions }); });
+                }, function () { return ({ theConfig: theConfig, core: core, extensions: extensions }); });
             };
             _self.processTelemetry = function (ev, itemCtx) {
                 setProcessTelemetryTimings(ev, _self.identifier);
-                itemCtx = _self._getTelCtx(itemCtx);
-                // Get the channel instance from the current request/instance
-                var channelConfig = itemCtx.getExtCfg(_self.identifier);
-                // DisableTelemetry was defined in the config provided during initialization
-                var disableTelemetry = !!_config.disableTelemetry;
-                if (channelConfig) {
-                    // DisableTelemetry is defined in the config for this request/instance
-                    disableTelemetry = disableTelemetry || !!channelConfig.disableTelemetry;
-                }
+                itemCtx = itemCtx || _self._getTelCtx(itemCtx);
                 var event = ev;
-                if (!disableTelemetry && !_isTeardownCalled) {
+                if (!_disableTelemetry && !_isTeardownCalled) {
                     // Override iKey if provided in Post config if provided for during initialization
-                    if (_config[strOverrideInstrumentationKey]) {
-                        event.iKey = _config[strOverrideInstrumentationKey];
-                    }
-                    // Override iKey if provided in Post config if provided for this instance
-                    if (channelConfig && channelConfig[strOverrideInstrumentationKey]) {
-                        event.iKey = channelConfig[strOverrideInstrumentationKey];
+                    if (_overrideInstrumentationKey) {
+                        event.iKey = _overrideInstrumentationKey;
                     }
                     _addEventToQueues(event, true);
                     if (_isPageUnloadTriggered) {
@@ -167,20 +190,23 @@ var PostChannel = /** @class */ (function (_super) {
                 _releaseAllQueues(2 /* EventSendType.SendBeacon */, 2 /* SendRequestReason.Unload */);
                 _isTeardownCalled = true;
                 _httpManager.teardown();
-                removePageUnloadEventListener(null, _evtNamespace);
-                removePageHideEventListener(null, _evtNamespace);
-                removePageShowEventListener(null, _evtNamespace);
+                _removeUnloadHandlers();
                 // Just register to remove all events associated with this namespace
                 _initDefaults();
             };
-            function _hookWParam(extendedCore) {
-                var existingGetWParamMethod = extendedCore.getWParam;
-                extendedCore.getWParam = function () {
+            function _removeUnloadHandlers() {
+                removePageUnloadEventListener(null, _evtNamespace);
+                removePageHideEventListener(null, _evtNamespace);
+                removePageShowEventListener(null, _evtNamespace);
+            }
+            function _hookWParam(core) {
+                var existingGetWParamMethod = core.getWParam;
+                core.getWParam = function () {
                     var wparam = 0;
-                    if (_config.ignoreMc1Ms0CookieProcessing) {
+                    if (_ignoreMc1Ms0CookieProcessing) {
                         wparam = wparam | 2;
                     }
-                    return wparam | existingGetWParamMethod();
+                    return wparam | existingGetWParamMethod.call(core);
                 };
             }
             // Moving event handlers out from the initialize closure so that any local variables can be garbage collected
@@ -216,7 +242,6 @@ var PostChannel = /** @class */ (function (_super) {
                 }
                 // v8 performance optimization for iterating over the keys
                 if (_optimizeObject) {
-                    setProcessTelemetryTimings;
                     event.ext = optimizeObject(event.ext);
                     if (event.baseData) {
                         event.baseData = optimizeObject(event.baseData);
@@ -276,8 +301,8 @@ var PostChannel = /** @class */ (function (_super) {
                 }
             }
             _self.setEventQueueLimits = function (eventLimit, autoFlushLimit) {
-                _queueSizeLimit = eventLimit > 0 ? eventLimit : 10000;
-                _autoFlushEventsLimit = autoFlushLimit > 0 ? autoFlushLimit : 0;
+                _postConfig.eventsLimitInMem = _queueSizeLimit = isGreaterThanZero(eventLimit) ? eventLimit : MaxEventsLimitInMem;
+                _postConfig.autoFlushEventsLimit = _autoFlushEventsLimit = isGreaterThanZero(autoFlushLimit) ? autoFlushLimit : 0;
                 _setAutoLimits();
                 // We only do this check here as during normal event addition if the queue is > then events start getting dropped
                 var doFlush = _queueSize > eventLimit;
@@ -307,9 +332,6 @@ var PostChannel = /** @class */ (function (_super) {
                 _httpManager.resume();
                 _scheduleTimer();
             };
-            _self.addResponseHandler = function (responseHandler) {
-                _httpManager._responseHandlers.push(responseHandler);
-            };
             _self._loadTransmitProfiles = function (profiles) {
                 _resetTransmitProfiles();
                 objForEachKey(profiles, function (profileName, profileValue) {
@@ -339,16 +361,23 @@ var PostChannel = /** @class */ (function (_super) {
             };
             _self.flush = function (async, callback, sendReason) {
                 if (async === void 0) { async = true; }
+                var result;
                 if (!_paused) {
                     sendReason = sendReason || 1 /* SendRequestReason.ManualFlush */;
                     if (async) {
-                        if (_flushCallbackTimerId == null) {
+                        if (!callback) {
+                            result = createPromise(function (resolve) {
+                                // Set the callback to the promise resolve callback
+                                callback = resolve;
+                            });
+                        }
+                        if (_flushCallbackTimer == 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;
+                            _flushCallbackTimer = _createTimer(function () {
+                                _flushCallbackTimer = null;
                                 _flushImpl(callback, sendReason);
                             }, 0);
                         }
@@ -363,15 +392,14 @@ var PostChannel = /** @class */ (function (_super) {
                         var cleared = _clearScheduledTimer();
                         // Now cause all queued events to be sent synchronously
                         _sendEventsForLatencyAndAbove(1 /* EventLatencyValue.Normal */, 1 /* EventSendType.Synchronous */, sendReason);
-                        if (callback !== null && callback !== undefined) {
-                            callback();
-                        }
+                        callback && callback();
                         if (cleared) {
                             // restart the normal event timer if it was cleared
                             _scheduleTimer();
                         }
                     }
                 }
+                return result;
             };
             _self.setMsaAuthTicket = function (ticket) {
                 _httpManager.addHeader(STR_MSA_DEVICE_TICKET, ticket);
@@ -384,6 +412,7 @@ var PostChannel = /** @class */ (function (_super) {
                     _scheduleTimer();
                 }
             };
+            proxyFunctions(_self, function () { return _httpManager; }, ["addResponseHandler"]);
             /**
              * Batch and send events currently in the queue for the given latency.
              * @param latency - Latency for which to send events.
@@ -408,13 +437,13 @@ var PostChannel = /** @class */ (function (_super) {
                 if (_delayedBatchSendLatency >= 0 && _queueBatches(_delayedBatchSendLatency, 0 /* EventSendType.Batched */, _delayedBatchReason)) {
                     _httpManager.sendQueuedRequests(0 /* EventSendType.Batched */, _delayedBatchReason);
                 }
-                if (_immediateQueueSize > 0 && !_immediateTimerId && !_paused) {
+                if (_immediateQueueSize > 0 && !_immediateTimer && !_paused) {
                     // During initialization _profiles enforce that the direct [2] is less than real time [1] timer value
                     // If the immediateTimeout is disabled the immediate events will be sent with Real Time events
                     var immediateTimeOut = _profiles[_currentProfile][2];
                     if (immediateTimeOut >= 0) {
-                        _immediateTimerId = _createTimer(function () {
-                            _immediateTimerId = null;
+                        _immediateTimer = _createTimer(function () {
+                            _immediateTimer = null;
                             // Only try to send direct events
                             _sendEventsForLatencyAndAbove(4 /* EventLatencyValue.Immediate */, 0 /* EventSendType.Batched */, 1 /* SendRequestReason.NormalSchedule */);
                             _scheduleTimer();
@@ -423,10 +452,10 @@ var PostChannel = /** @class */ (function (_super) {
                 }
                 // During initialization the _profiles enforce that the normal [0] is a multiple of the real time [1] timer value
                 var timeOut = _profiles[_currentProfile][1];
-                if (!_scheduledTimerId && !_flushCallbackTimerId && timeOut >= 0 && !_paused) {
+                if (!_scheduledTimer && !_flushCallbackTimer && timeOut >= 0 && !_paused) {
                     if (_hasEvents()) {
-                        _scheduledTimerId = _createTimer(function () {
-                            _scheduledTimerId = null;
+                        _scheduledTimer = _createTimer(function () {
+                            _scheduledTimer = null;
                             _sendEventsForLatencyAndAbove(_timerCount === 0 ? 3 /* EventLatencyValue.RealTime */ : 1 /* EventLatencyValue.Normal */, 0 /* EventSendType.Batched */, 1 /* SendRequestReason.NormalSchedule */);
                             // Increment the count for next cycle
                             _timerCount++;
@@ -454,24 +483,24 @@ var PostChannel = /** @class */ (function (_super) {
                 }
             };
             function _initDefaults() {
-                _config = null;
+                _postConfig = null;
                 _isTeardownCalled = false;
                 _flushCallbackQueue = [];
-                _flushCallbackTimerId = null;
+                _flushCallbackTimer = null;
                 _paused = false;
                 _immediateQueueSize = 0;
                 _immediateQueueSizeLimit = 500;
                 _queueSize = 0;
-                _queueSizeLimit = 10000;
+                _queueSizeLimit = MaxEventsLimitInMem;
                 _profiles = {};
                 _currentProfile = RT_PROFILE;
-                _scheduledTimerId = null;
-                _immediateTimerId = null;
+                _scheduledTimer = null;
+                _immediateTimer = null;
                 _currentBackoffCount = 0;
                 _timerCount = 0;
-                _xhrOverride = null;
                 _batchQueues = {};
-                _autoFlushEventsLimit = undefined;
+                _autoFlushEventsLimit = 0;
+                _unloadHandlersAdded = false;
                 // 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;
@@ -481,6 +510,8 @@ var PostChannel = /** @class */ (function (_super) {
                 _maxEventSendAttempts = MaxSendAttempts;
                 _maxUnloadEventSendAttempts = MaxSyncUnloadSendAttempts;
                 _evtNamespace = null;
+                _overrideInstrumentationKey = null;
+                _disableTelemetry = false;
                 _timeoutWrapper = createTimeoutWrapper();
                 _httpManager = new HttpManager(MaxNumberEventPerBatch, MaxConnections, MaxRequestRetriesBeforeBackoff, {
                     requeue: _requeueEvents,
@@ -489,7 +520,7 @@ var PostChannel = /** @class */ (function (_super) {
                     drop: _eventsDropped,
                     rspFail: _eventsResponseFail,
                     oth: _otherEvent
-                }, _timeoutWrapper);
+                });
                 _initializeProfiles();
                 _clearQueues();
                 _setAutoLimits();
@@ -506,9 +537,9 @@ var PostChannel = /** @class */ (function (_super) {
                 return _timeoutWrapper.set(theTimerFunc, timeOut * timerMultiplier);
             }
             function _clearScheduledTimer() {
-                if (_scheduledTimerId !== null) {
-                    _timeoutWrapper.clear(_scheduledTimerId);
-                    _scheduledTimerId = null;
+                if (_scheduledTimer !== null) {
+                    _scheduledTimer.cancel();
+                    _scheduledTimer = null;
                     _timerCount = 0;
                     return true;
                 }
@@ -518,9 +549,9 @@ var PostChannel = /** @class */ (function (_super) {
             function _releaseAllQueues(sendType, sendReason) {
                 _clearScheduledTimer();
                 // Cancel all flush callbacks
-                if (_flushCallbackTimerId) {
-                    _timeoutWrapper.clear(_flushCallbackTimerId);
-                    _flushCallbackTimerId = null;
+                if (_flushCallbackTimer) {
+                    _flushCallbackTimer.cancel();
+                    _flushCallbackTimer = null;
                 }
                 if (!_paused) {
                     // Queue all the remaining requests to be sent. The requests will be sent using HTML5 Beacons if they are available.
@@ -571,9 +602,9 @@ var PostChannel = /** @class */ (function (_super) {
                         // Force flushing
                         doFlush = true;
                     }
-                    if (doFlush && _flushCallbackTimerId == null) {
-                        // Auto flush the queue
-                        _self.flush(isAsync, null, 20 /* SendRequestReason.MaxQueuedEvents */);
+                    if (doFlush && _flushCallbackTimer == null) {
+                        // Auto flush the queue, adding a callback to avoid the creation of a promise
+                        _self.flush(isAsync, function () { }, 20 /* SendRequestReason.MaxQueuedEvents */);
                     }
                 }
             }
@@ -719,14 +750,14 @@ var PostChannel = /** @class */ (function (_super) {
                         callback();
                     }
                     if (_flushCallbackQueue.length > 0) {
-                        _flushCallbackTimerId = _createTimer(function () {
-                            _flushCallbackTimerId = null;
+                        _flushCallbackTimer = _createTimer(function () {
+                            _flushCallbackTimer = null;
                             _flushImpl(_flushCallbackQueue.shift(), sendReason);
                         }, 0);
                     }
                     else {
                         // No more flush requests
-                        _flushCallbackTimerId = null;
+                        _flushCallbackTimer = null;
                         // Restart the normal timer schedule
                         _scheduleTimer();
                     }
@@ -737,8 +768,8 @@ var PostChannel = /** @class */ (function (_super) {
                     callback();
                 }
                 else {
-                    _flushCallbackTimerId = _createTimer(function () {
-                        _flushCallbackTimerId = null;
+                    _flushCallbackTimer = _createTimer(function () {
+                        _flushCallbackTimer = null;
                         _waitForIdleManager(callback);
                     }, FlushCheckTimer);
                 }
@@ -800,7 +831,7 @@ var PostChannel = /** @class */ (function (_super) {
                 }
             }
             function _callNotification(evtName, theArgs) {
-                var manager = (_self._notificationManager || {});
+                var manager = (_notificationManager || {});
                 var notifyFunc = manager[evtName];
                 if (notifyFunc) {
                     try {
@@ -870,22 +901,13 @@ var PostChannel = /** @class */ (function (_super) {
                 _scheduleTimer();
             }
             function _setAutoLimits() {
-                if (!_config || !_config.disableAutoBatchFlushLimit) {
+                if (!_disableAutoBatchFlushLimit) {
                     _autoFlushBatchLimit = Math.max(MaxNumberEventPerBatch * (MaxConnections + 1), _queueSizeLimit / 6);
                 }
                 else {
                     _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;
     }
@@ -909,5 +931,5 @@ var PostChannel = /** @class */ (function (_super) {
 
     return PostChannel;
 }(BaseTelemetryPlugin));
-export default PostChannel;
+export { PostChannel };
 //# sourceMappingURL=PostChannel.js.map