@microsoft/applicationinsights-channel-js 3.0.4-nightly3.2309-08 → 3.0.4-nightly3.2309-10

package/dist-es5/Sender.js

@@ -1,5 +1,5 @@
 /*
- * Application Insights JavaScript SDK - Channel, 3.0.4-nightly3.2309-08
+ * Application Insights JavaScript SDK - Channel, 3.0.4-nightly3.2309-10
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 var _a, _b;
@@ -8,13 +8,13 @@ import dynamicProto from "@microsoft/dynamicproto-js";
 import { BreezeChannelIdentifier, DEFAULT_BREEZE_ENDPOINT, DEFAULT_BREEZE_PATH, DisabledPropertyName, Event, Exception, Metric, PageView, PageViewPerformance, ProcessLegacy, RemoteDependencyData, RequestHeaders, SampleRate, Trace, isInternalApplicationInsightsEndpoint, utlCanUseSessionStorage, utlSetStoragePrefix } from "@microsoft/applicationinsights-common";
 import { BaseTelemetryPlugin, _throwInternal, _warnToConsole, arrForEach, cfgDfBoolean, cfgDfValidate, createProcessTelemetryContext, createUniqueNamespace, dateNow, dumpObj, getExceptionName, getIEVersion, getJSON, getNavigator, getWindow, isArray, isBeaconsSupported, isFetchSupported, isNullOrUndefined, isXhrSupported, mergeEvtNamespace, objExtend, objKeys, onConfigChange, runTargetUnload, useXDomainRequest } from "@microsoft/applicationinsights-core-js";
 import { createPromise, doAwaitResponse } from "@nevware21/ts-async";
-import { isTruthy, objDeepFreeze, objDefine, scheduleTimeout } from "@nevware21/ts-utils";
+import { isString, isTruthy, objDeepFreeze, objDefine, scheduleTimeout } from "@nevware21/ts-utils";
 import { DependencyEnvelopeCreator, EventEnvelopeCreator, ExceptionEnvelopeCreator, MetricEnvelopeCreator, PageViewEnvelopeCreator, PageViewPerformanceEnvelopeCreator, TraceEnvelopeCreator } from "./EnvelopeCreator";
 import { createOfflineListener } from "./Offline";
 import { ArraySendBuffer, SessionStorageSendBuffer } from "./SendBuffer";
 import { Serializer } from "./Serializer";
 import { Sample } from "./TelemetryProcessors/Sample";
-import { _DYN_BASE_TYPE, _DYN_BATCH_PAYLOADS, _DYN_BUFFER_OVERRIDE, _DYN_CLEAR, _DYN_CLEAR_SENT, _DYN_CONVERT_UNDEFINED, _DYN_COUNT, _DYN_CREATE_NEW, _DYN_CUSTOM_HEADERS, _DYN_DIAG_LOG, _DYN_DISABLE_XHR, _DYN_EMIT_LINE_DELIMITED_0, _DYN_ENABLE_SESSION_STORA4, _DYN_ENQUEUE, _DYN_EVENTS_LIMIT_IN_MEM, _DYN_EVENTS_SEND_REQUEST, _DYN_INSTRUMENTATION_KEY, _DYN_IS_BEACON_API_DISABL3, _DYN_IS_ONLINE, _DYN_ITEMS_ACCEPTED, _DYN_ITEMS_RECEIVED, _DYN_LENGTH, _DYN_MARK_AS_SENT, _DYN_MAX_BATCH_INTERVAL, _DYN_MAX_BATCH_SIZE_IN_BY1, _DYN_ONUNLOAD_DISABLE_BEA2, _DYN_ONUNLOAD_DISABLE_FET5, _DYN_PUSH, _DYN_SAMPLE_RATE, _DYN_SET_REQUEST_HEADER, _DYN_TAGS, _DYN_TRIGGER_SEND, _DYN__BUFFER, _DYN__ON_ERROR, _DYN__ON_PARTIAL_SUCCESS, _DYN__ON_SUCCESS, _DYN__SENDER, _DYN__XHR_READY_STATE_CHA6 } from "./__DynamicConstants";
+import { _DYN_ALWAYS_USE_XHR_OVERR4, _DYN_BASE_TYPE, _DYN_BATCH_PAYLOADS, _DYN_BUFFER_OVERRIDE, _DYN_CLEAR, _DYN_CLEAR_SENT, _DYN_CONVERT_UNDEFINED, _DYN_COUNT, _DYN_CREATE_NEW, _DYN_CUSTOM_HEADERS, _DYN_DATA, _DYN_DIAG_LOG, _DYN_EMIT_LINE_DELIMITED_0, _DYN_ENABLE_SESSION_STORA5, _DYN_ENQUEUE, _DYN_EVENTS_LIMIT_IN_MEM, _DYN_EVENTS_SEND_REQUEST, _DYN_INSTRUMENTATION_KEY, _DYN_IS_BEACON_API_DISABL3, _DYN_IS_ONLINE, _DYN_ITEMS_ACCEPTED, _DYN_ITEMS_RECEIVED, _DYN_LENGTH, _DYN_MARK_AS_SENT, _DYN_MAX_BATCH_INTERVAL, _DYN_MAX_BATCH_SIZE_IN_BY1, _DYN_ONUNLOAD_DISABLE_BEA2, _DYN_ONUNLOAD_DISABLE_FET6, _DYN_ORI_PAYLOAD, _DYN_PUSH, _DYN_SAMPLE_RATE, _DYN_SEND_POST, _DYN_SET_REQUEST_HEADER, _DYN_TAGS, _DYN_TRIGGER_SEND, _DYN__BUFFER, _DYN__ON_ERROR, _DYN__ON_PARTIAL_SUCCESS, _DYN__ON_SUCCESS, _DYN__SENDER, _DYN__XHR_READY_STATE_CHA7 } from "./__DynamicConstants";
 var UNDEFINED_VALUE = undefined;
 var FetchSyncRequestSizeLimitBytes = 65000; // approx 64kb (the current Edge, Firefox and Chrome max limit)
 function _getResponseText(xhr) {
@@ -26,6 +26,9 @@ function _getResponseText(xhr) {
     }
     return null;
 }
+function isOverrideFn(httpXHROverride) {
+    return httpXHROverride && httpXHROverride[_DYN_SEND_POST /* @min:%2esendPOST */];
+}
 var defaultAppInsightsChannelConfig = objDeepFreeze((_a = {
         // Use the default value (handles empty string in the configuration)
         endpointUrl: cfgDfValidate(isTruthy, DEFAULT_BREEZE_ENDPOINT + DEFAULT_BREEZE_PATH)
@@ -34,11 +37,11 @@ var defaultAppInsightsChannelConfig = objDeepFreeze((_a = {
     _a[_DYN_MAX_BATCH_INTERVAL /* @min:maxBatchInterval */] = 15000,
     _a[_DYN_MAX_BATCH_SIZE_IN_BY1 /* @min:maxBatchSizeInBytes */] = 102400,
     _a.disableTelemetry = cfgDfBoolean(),
-    _a[_DYN_ENABLE_SESSION_STORA4 /* @min:enableSessionStorageBuffer */] = cfgDfBoolean(true),
+    _a[_DYN_ENABLE_SESSION_STORA5 /* @min:enableSessionStorageBuffer */] = cfgDfBoolean(true),
     _a.isRetryDisabled = cfgDfBoolean(),
     _a[_DYN_IS_BEACON_API_DISABL3 /* @min:isBeaconApiDisabled */] = cfgDfBoolean(true),
-    _a[_DYN_DISABLE_XHR /* @min:disableXhr */] = cfgDfBoolean(),
-    _a[_DYN_ONUNLOAD_DISABLE_FET5 /* @min:onunloadDisableFetch */] = cfgDfBoolean(),
+    _a.disableXhr = cfgDfBoolean(),
+    _a[_DYN_ONUNLOAD_DISABLE_FET6 /* @min:onunloadDisableFetch */] = cfgDfBoolean(),
     _a[_DYN_ONUNLOAD_DISABLE_BEA2 /* @min:onunloadDisableBeacon */] = cfgDfBoolean(),
     _a[_DYN_INSTRUMENTATION_KEY /* @min:instrumentationKey */] = UNDEFINED_VALUE,
     _a.namePrefix = UNDEFINED_VALUE,
@@ -47,6 +50,8 @@ var defaultAppInsightsChannelConfig = objDeepFreeze((_a = {
     _a[_DYN_CONVERT_UNDEFINED /* @min:convertUndefined */] = UNDEFINED_VALUE,
     _a[_DYN_EVENTS_LIMIT_IN_MEM /* @min:eventsLimitInMem */] = 10000,
     _a[_DYN_BUFFER_OVERRIDE /* @min:bufferOverride */] = false,
+    _a.httpXHROverride = { isVal: isOverrideFn, v: UNDEFINED_VALUE },
+    _a[_DYN_ALWAYS_USE_XHR_OVERR4 /* @min:alwaysUseXhrOverride */] = cfgDfBoolean(),
     _a));
 function _chkSampling(value) {
     return !isNaN(value) && value > 0 && value <= 100;
@@ -76,7 +81,6 @@ var Sender = /** @class */ (function (_super) {
         var _stamp_specific_redirects;
         var _headers;
         var _syncFetchPayload = 0; // Keep track of the outstanding sync fetch payload total (as sync fetch has limits)
-        var _fallbackSender; // The sender to use if the payload size is too large
         var _syncUnloadSender; // The identified sender to use for the synchronous unload stage
         var _offlineListener;
         var _evtNamespace;
@@ -94,6 +98,10 @@ var Sender = /** @class */ (function (_super) {
         var _bufferOverrideUsed;
         var _namePrefix;
         var _enableSendPromise;
+        var _alwaysUseCustomSend;
+        var _disableXhr;
+        var _fetchKeepAlive;
+        var _xhrSend;
         dynamicProto(Sender, _this, function (_self, _base) {
             _initDefaults();
             _self.pause = function () {
@@ -124,7 +132,7 @@ var Sender = /** @class */ (function (_super) {
             };
             _self.onunloadFlush = function () {
                 if (!_paused) {
-                    if (_beaconSupported) {
+                    if (_beaconSupported || _alwaysUseCustomSend) {
                         try {
                             return _self[_DYN_TRIGGER_SEND /* @min:%2etriggerSend */](true, _doUnloadSend, 2 /* SendRequestReason.Unload */);
                         }
@@ -184,8 +192,10 @@ var Sender = /** @class */ (function (_super) {
                     }
                     _maxBatchSizeInBytes = senderConfig[_DYN_MAX_BATCH_SIZE_IN_BY1 /* @min:%2emaxBatchSizeInBytes */];
                     _beaconSupported = (senderConfig[_DYN_ONUNLOAD_DISABLE_BEA2 /* @min:%2eonunloadDisableBeacon */] === false || senderConfig[_DYN_IS_BEACON_API_DISABL3 /* @min:%2eisBeaconApiDisabled */] === false) && isBeaconsSupported();
+                    _alwaysUseCustomSend = senderConfig[_DYN_ALWAYS_USE_XHR_OVERR4 /* @min:%2ealwaysUseXhrOverride */];
+                    _disableXhr = !!senderConfig.disableXhr;
                     var bufferOverride = senderConfig[_DYN_BUFFER_OVERRIDE /* @min:%2ebufferOverride */];
-                    var canUseSessionStorage = !!senderConfig[_DYN_ENABLE_SESSION_STORA4 /* @min:%2eenableSessionStorageBuffer */] &&
+                    var canUseSessionStorage = !!senderConfig[_DYN_ENABLE_SESSION_STORA5 /* @min:%2eenableSessionStorageBuffer */] &&
                         (!!bufferOverride || utlCanUseSessionStorage());
                     var namePrefix = senderConfig.namePrefix;
                     //Note: emitLineDelimitedJson and eventsLimitInMem is directly accessed via config in senderBuffer
@@ -216,6 +226,7 @@ var Sender = /** @class */ (function (_super) {
                     _namePrefix = namePrefix;
                     _sessionStorageUsed = canUseSessionStorage;
                     _bufferOverrideUsed = bufferOverride;
+                    _fetchKeepAlive = !senderConfig[_DYN_ONUNLOAD_DISABLE_FET6 /* @min:%2eonunloadDisableFetch */] && isFetchSupported(true);
                     _self._sample = new Sample(senderConfig.samplingPercentage, diagLog);
                     _instrumentationKey = senderConfig[_DYN_INSTRUMENTATION_KEY /* @min:%2einstrumentationKey */];
                     if (!_validateInstrumentationKey(_instrumentationKey, config)) {
@@ -231,39 +242,34 @@ var Sender = /** @class */ (function (_super) {
                         _customHeaders = null;
                     }
                     _enableSendPromise = senderConfig.enableSendPromise;
-                    var sendPostFunc = null;
-                    if (!senderConfig[_DYN_DISABLE_XHR /* @min:%2edisableXhr */] && useXDomainRequest()) {
-                        sendPostFunc = _xdrSender; // IE 8 and 9
-                    }
-                    else if (!senderConfig[_DYN_DISABLE_XHR /* @min:%2edisableXhr */] && isXhrSupported()) {
-                        sendPostFunc = _xhrSender;
-                    }
-                    if (!sendPostFunc && isFetchSupported()) {
-                        sendPostFunc = _fetchSender;
-                    }
-                    // always fallback to XHR
-                    _fallbackSender = sendPostFunc || _xhrSender;
+                    var customInterface = senderConfig.httpXHROverride;
+                    var httpInterface = null;
+                    var syncInterface = null;
+                    httpInterface = _getSenderInterface([1 /* TransportType.Xhr */, 2 /* TransportType.Fetch */], false);
+                    var xhrInterface = { sendPOST: _xhrSender };
+                    _xhrSend = function (payload, isAsync) {
+                        return _doSend(xhrInterface, payload, isAsync);
+                    };
                     if (!senderConfig[_DYN_IS_BEACON_API_DISABL3 /* @min:%2eisBeaconApiDisabled */] && isBeaconsSupported()) {
                         // Config is set to always used beacon sending
-                        sendPostFunc = _beaconSender;
+                        httpInterface = _getSenderInterface([3 /* TransportType.Beacon */], false);
                     }
-                    _self[_DYN__SENDER /* @min:%2e_sender */] = sendPostFunc || _xhrSender;
-                    if (!senderConfig[_DYN_ONUNLOAD_DISABLE_FET5 /* @min:%2eonunloadDisableFetch */] && isFetchSupported(true)) {
+                    httpInterface = _alwaysUseCustomSend ? customInterface : (httpInterface || customInterface || xhrInterface);
+                    _self[_DYN__SENDER /* @min:%2e_sender */] = function (payload, isAsync) {
+                        return _doSend(httpInterface, payload, isAsync);
+                    };
+                    if (_fetchKeepAlive) {
                         // Try and use the fetch with keepalive
                         _syncUnloadSender = _fetchKeepAliveSender;
                     }
-                    else if (isBeaconsSupported()) {
-                        // Try and use sendBeacon
-                        _syncUnloadSender = _beaconSender;
-                    }
-                    else if (!senderConfig[_DYN_DISABLE_XHR /* @min:%2edisableXhr */] && useXDomainRequest()) {
-                        _syncUnloadSender = _xdrSender; // IE 8 and 9
+                    syncInterface = _alwaysUseCustomSend ? customInterface : (_getSenderInterface([3 /* TransportType.Beacon */, 1 /* TransportType.Xhr */], true) || customInterface);
+                    if ((_alwaysUseCustomSend || !_syncUnloadSender) && syncInterface) {
+                        _syncUnloadSender = function (payload, isAsync) {
+                            return _doSend(syncInterface, payload, isAsync);
+                        };
                     }
-                    else if (!senderConfig[_DYN_DISABLE_XHR /* @min:%2edisableXhr */] && isXhrSupported()) {
-                        _syncUnloadSender = _xhrSender;
-                    }
-                    else {
-                        _syncUnloadSender = _fallbackSender;
+                    if (!_syncUnloadSender) {
+                        _syncUnloadSender = _xhrSend;
                     }
                     _disableTelemetry = senderConfig.disableTelemetry;
                     _convertUndefined = senderConfig[_DYN_CONVERT_UNDEFINED /* @min:%2econvertUndefined */] || UNDEFINED_VALUE;
@@ -356,7 +362,7 @@ var Sender = /** @class */ (function (_super) {
             /**
              * xhr state changes
              */
-            _self[_DYN__XHR_READY_STATE_CHA6 /* @min:%2e_xhrReadyStateChange */] = function (xhr, payload, countOfItemsInPayload) {
+            _self[_DYN__XHR_READY_STATE_CHA7 /* @min:%2e_xhrReadyStateChange */] = function (xhr, payload, countOfItemsInPayload) {
                 if (xhr.readyState === 4) {
                     _checkResponsStatus(xhr.status, payload, xhr.responseURL, countOfItemsInPayload, _formatErrorMessageXhr(xhr), _getResponseText(xhr) || xhr.response);
                 }
@@ -476,6 +482,84 @@ var Sender = /** @class */ (function (_super) {
             function _isSampledIn(envelope) {
                 return _self._sample.isSampledIn(envelope);
             }
+            function _getSenderInterface(transports, syncSupport) {
+                var _a;
+                var transportType = null;
+                var sendPostFunc = null;
+                var lp = 0;
+                while (sendPostFunc == null && lp < transports[_DYN_LENGTH /* @min:%2elength */]) {
+                    transportType = transports[lp];
+                    if (!_disableXhr && transportType === 1 /* TransportType.Xhr */) {
+                        if (useXDomainRequest()) {
+                            // IE 8 and 9
+                            sendPostFunc = _xdrSender;
+                        }
+                        else if (isXhrSupported()) {
+                            sendPostFunc = _xhrSender;
+                        }
+                    }
+                    else if (transportType === 2 /* TransportType.Fetch */ && isFetchSupported(syncSupport)) {
+                        sendPostFunc = _fetchSender;
+                    }
+                    else if (isBeaconsSupported() && transportType === 3 /* TransportType.Beacon */) {
+                        sendPostFunc = _beaconSender;
+                    }
+                    lp++;
+                }
+                if (sendPostFunc) {
+                    return _a = {},
+                        _a[_DYN_SEND_POST /* @min:sendPOST */] = sendPostFunc,
+                        _a;
+                }
+                return null;
+            }
+            function _getOnComplete(payload, status, headers, response) {
+                // ***********************************************************************************************
+                //TODO: handle other status codes
+                if (status === 200 && payload) {
+                    _self._onSuccess(payload, payload[_DYN_LENGTH /* @min:%2elength */]);
+                }
+                response && _self[_DYN__ON_ERROR /* @min:%2e_onError */](payload, response);
+            }
+            function _doSend(sendInterface, payload, isAsync) {
+                var onComplete = function (status, headers, response) {
+                    return _getOnComplete(payload, status, headers, response);
+                };
+                var payloadData = _getPayload(payload);
+                var sendPostFunc = sendInterface && sendInterface[_DYN_SEND_POST /* @min:%2esendPOST */];
+                if (sendPostFunc && payloadData) {
+                    // ***********************************************************************************************
+                    // mark payload as sent at the beginning of calling each send function
+                    _self._buffer[_DYN_MARK_AS_SENT /* @min:%2emarkAsSent */](payload);
+                    return sendPostFunc(payloadData, onComplete, !isAsync);
+                }
+                return null;
+            }
+            function _getPayload(payload) {
+                var _a;
+                if (isArray(payload) && payload[_DYN_LENGTH /* @min:%2elength */] > 0) {
+                    var batch = _self._buffer[_DYN_BATCH_PAYLOADS /* @min:%2ebatchPayloads */](payload);
+                    var payloadData = (_a = {},
+                        _a[_DYN_DATA /* @min:data */] = batch,
+                        _a.urlString = _endpointUrl,
+                        _a.headers = _headers,
+                        _a.disableXhrSync = _disableXhr,
+                        _a.disableFetchKeepAlive = !_fetchKeepAlive,
+                        _a[_DYN_ORI_PAYLOAD /* @min:oriPayload */] = payload,
+                        _a);
+                    return payloadData;
+                }
+                return null;
+            }
+            /**
+             * Send fetch API request
+             * @param payload - {string} - The data payload to be sent.
+             * @param oncomplete - {function} on complete function
+             * @param sync - {boolean} - not used
+             */
+            function _fetchSender(payload, oncomplete, sync) {
+                return _doFetchSender(payload, oncomplete, false);
+            }
             function _checkMaxSize(incomingPayload) {
                 var incomingSize = incomingPayload ? incomingPayload[_DYN_LENGTH /* @min:%2elength */] : 0;
                 if ((_self[_DYN__BUFFER /* @min:%2e_buffer */].size() + incomingSize) > _maxBatchSizeInBytes) {
@@ -557,55 +641,69 @@ var Sender = /** @class */ (function (_super) {
                 }
                 return false;
             }
+            function _doOnComplete(oncomplete, status, headers, response) {
+                try {
+                    oncomplete(status, headers, response);
+                }
+                catch (e) {
+                    // eslint-disable-next-line no-empty
+                }
+            }
             function _doUnloadSend(payload, isAsync) {
+                var onComplete = function (status, headers, response) {
+                    return _getOnComplete(payload, status, headers, response);
+                };
                 if (_syncUnloadSender) {
                     // We are unloading so always call the sender with sync set to false
                     _syncUnloadSender(payload, false);
                 }
                 else {
                     // Fallback to the previous beacon Sender (which causes a CORB warning on chrome now)
-                    _beaconSender(payload, isAsync);
+                    var payloadData = _getPayload(payload);
+                    _beaconSender(payloadData, onComplete, !isAsync);
                 }
             }
-            function _doBeaconSend(payload) {
+            function _doBeaconSend(payload, oncomplete) {
                 var nav = getNavigator();
-                var buffer = _self[_DYN__BUFFER /* @min:%2e_buffer */];
                 var url = _endpointUrl;
-                var batch = _self._buffer[_DYN_BATCH_PAYLOADS /* @min:%2ebatchPayloads */](payload);
                 // Chrome only allows CORS-safelisted values for the sendBeacon data argument
                 // see: https://bugs.chromium.org/p/chromium/issues/detail?id=720283
-                var plainTextBatch = new Blob([batch], { type: "text/plain;charset=UTF-8" });
+                var plainTextBatch = new Blob([payload], { type: "text/plain;charset=UTF-8" });
                 // The sendBeacon method returns true if the user agent is able to successfully queue the data for transfer. Otherwise it returns false.
                 var queued = nav.sendBeacon(url, plainTextBatch);
                 if (queued) {
-                    buffer[_DYN_MARK_AS_SENT /* @min:%2emarkAsSent */](payload);
-                    // no response from beaconSender, clear buffer
-                    _self._onSuccess(payload, payload[_DYN_LENGTH /* @min:%2elength */]);
+                    oncomplete(200, {}, payload);
                 }
                 return queued;
             }
             /**
              * Send Beacon API request
              * @param payload - {string} - The data payload to be sent.
-             * @param isAsync - {boolean} - not used
+             * @param sync - {boolean} - not used
              * Note: Beacon API does not support custom headers and we are not able to get
              * appId from the backend for the correct correlation.
              */
-            function _beaconSender(payload, isAsync) {
-                if (isArray(payload) && payload[_DYN_LENGTH /* @min:%2elength */] > 0) {
+            function _beaconSender(payload, oncomplete, sync) {
+                var internalPayload = payload;
+                var data = internalPayload && internalPayload[_DYN_DATA /* @min:%2edata */];
+                if (isString(data) && data[_DYN_LENGTH /* @min:%2elength */] > 0) {
                     // The sendBeacon method returns true if the user agent is able to successfully queue the data for transfer. Otherwise it returns false.
-                    if (!_doBeaconSend(payload)) {
+                    if (!_doBeaconSend(data, oncomplete)) {
                         // Failed to send entire payload so try and split data and try to send as much events as possible
                         var droppedPayload = [];
-                        for (var lp = 0; lp < payload[_DYN_LENGTH /* @min:%2elength */]; lp++) {
-                            var thePayload = payload[lp];
-                            if (!_doBeaconSend([thePayload])) {
-                                // Can't send anymore, so split the batch and drop the rest
-                                droppedPayload[_DYN_PUSH /* @min:%2epush */](thePayload);
+                        var oriPayload = internalPayload[_DYN_ORI_PAYLOAD /* @min:%2eoriPayload */];
+                        if (oriPayload[_DYN_LENGTH /* @min:%2elength */] > 0) {
+                            for (var lp = 0; lp < data[_DYN_LENGTH /* @min:%2elength */]; lp++) {
+                                var thePayload = payload[lp];
+                                var batch = _self._buffer[_DYN_BATCH_PAYLOADS /* @min:%2ebatchPayloads */](thePayload);
+                                if (!_doBeaconSend(batch, oncomplete)) {
+                                    // Can't send anymore, so split the batch and drop the rest
+                                    droppedPayload[_DYN_PUSH /* @min:%2epush */](thePayload);
+                                }
                             }
                         }
                         if (droppedPayload[_DYN_LENGTH /* @min:%2elength */] > 0) {
-                            _fallbackSender && _fallbackSender(droppedPayload, true);
+                            _xhrSend && _xhrSend(droppedPayload, true);
                             _throwInternal(_self[_DYN_DIAG_LOG /* @min:%2ediagLog */](), 2 /* eLoggingSeverity.WARNING */, 40 /* _eInternalMessageId.TransmissionFailed */, ". " + "Failed to send telemetry with Beacon API, retried with normal sender.");
                         }
                     }
@@ -614,9 +712,10 @@ var Sender = /** @class */ (function (_super) {
             /**
              * Send XMLHttpRequest
              * @param payload - {string} - The data payload to be sent.
-             * @param isAsync - {boolean} - Indicates if the request should be sent asynchronously
+             * @param sync - {boolean} - Indicates if the request should be sent synchronously
              */
-            function _xhrSender(payload, isAsync) {
+            function _xhrSender(payload, oncomplete, sync) {
+                var internalPayload = payload;
                 var thePromise;
                 var resolveFunc;
                 var rejectFunc;
@@ -629,7 +728,7 @@ var Sender = /** @class */ (function (_super) {
                     // If the environment has locked down the XMLHttpRequest (preventExtensions and/or freeze), this would
                     // cause the request to fail and we no telemetry would be sent
                 }
-                xhr.open("POST", endPointUrl, isAsync);
+                xhr.open("POST", endPointUrl, !sync);
                 xhr[_DYN_SET_REQUEST_HEADER /* @min:%2esetRequestHeader */]("Content-type", "application/json");
                 // append Sdk-Context request header only in case of breeze endpoint
                 if (isInternalApplicationInsightsEndpoint(endPointUrl)) {
@@ -639,43 +738,45 @@ var Sender = /** @class */ (function (_super) {
                     xhr[_DYN_SET_REQUEST_HEADER /* @min:%2esetRequestHeader */](headerName, _headers[headerName]);
                 });
                 xhr.onreadystatechange = function () {
-                    _self._xhrReadyStateChange(xhr, payload, payload[_DYN_LENGTH /* @min:%2elength */]);
+                    var oriPayload = internalPayload[_DYN_ORI_PAYLOAD /* @min:%2eoriPayload */];
+                    _self._xhrReadyStateChange(xhr, oriPayload, oriPayload[_DYN_LENGTH /* @min:%2elength */]);
                     if (xhr.readyState === 4) {
                         resolveFunc && resolveFunc(true);
                     }
                 };
                 xhr.onerror = function (event) {
-                    _self[_DYN__ON_ERROR /* @min:%2e_onError */](payload, _formatErrorMessageXhr(xhr), event);
+                    _doOnComplete(oncomplete, 400, {}, _formatErrorMessageXhr(xhr));
                     rejectFunc && rejectFunc(event);
                 };
-                if (isAsync && _enableSendPromise) {
+                if (!sync && _enableSendPromise) {
                     thePromise = createPromise(function (resolve, reject) {
                         resolveFunc = resolve;
                         rejectFunc = reject;
                     });
                 }
-                // compose an array of payloads
-                var batch = _self._buffer[_DYN_BATCH_PAYLOADS /* @min:%2ebatchPayloads */](payload);
-                xhr.send(batch);
-                _self._buffer[_DYN_MARK_AS_SENT /* @min:%2emarkAsSent */](payload);
+                xhr.send(payload[_DYN_DATA /* @min:%2edata */]);
                 return thePromise;
             }
             function _fetchKeepAliveSender(payload, isAsync) {
+                var onComplete = function (status, headers, response) {
+                    return _getOnComplete(payload, status, headers, response);
+                };
                 if (isArray(payload)) {
                     var payloadSize = payload[_DYN_LENGTH /* @min:%2elength */];
                     for (var lp = 0; lp < payload[_DYN_LENGTH /* @min:%2elength */]; lp++) {
                         payloadSize += payload[lp][_DYN_LENGTH /* @min:%2elength */];
                     }
+                    var payloadData = _getPayload(payload);
                     if ((_syncFetchPayload + payloadSize) <= FetchSyncRequestSizeLimitBytes) {
-                        _doFetchSender(payload, false);
+                        _doFetchSender(payloadData, onComplete, true);
                     }
                     else if (isBeaconsSupported()) {
                         // Fallback to beacon sender as we at least get told which events can't be scheduled
-                        _beaconSender(payload, isAsync);
+                        _beaconSender(payloadData, onComplete, !isAsync);
                     }
                     else {
                         // Payload is going to be too big so just try and send via XHR
-                        _fallbackSender && _fallbackSender(payload, true);
+                        _xhrSend && _xhrSend(payload, true);
                         _throwInternal(_self[_DYN_DIAG_LOG /* @min:%2ediagLog */](), 2 /* eLoggingSeverity.WARNING */, 40 /* _eInternalMessageId.TransmissionFailed */, ". " + "Failed to send telemetry with Beacon API, retried with xhrSender.");
                     }
                 }
@@ -683,20 +784,13 @@ var Sender = /** @class */ (function (_super) {
             /**
              * Send fetch API request
              * @param payload - {string} - The data payload to be sent.
-             * @param isAsync - {boolean} - not used
-             */
-            function _fetchSender(payload, isAsync) {
-                return _doFetchSender(payload, true);
-            }
-            /**
-             * Send fetch API request
-             * @param payload - {string} - The data payload to be sent.
-             * @param isAsync - {boolean} - For fetch this identifies whether we are "unloading" (false) or a normal request
+             * @param sync - {boolean} - For fetch this identifies whether we are "unloading" (false) or a normal request
              */
-            function _doFetchSender(payload, isAsync) {
+            function _doFetchSender(payload, oncomplete, sync) {
                 var _a;
                 var endPointUrl = _endpointUrl;
-                var batch = _self._buffer[_DYN_BATCH_PAYLOADS /* @min:%2ebatchPayloads */](payload);
+                var internalPayload = payload;
+                var batch = internalPayload[_DYN_DATA /* @min:%2edata */];
                 var plainTextBatch = new Blob([batch], { type: "application/json" });
                 var thePromise;
                 var resolveFunc;
@@ -720,7 +814,7 @@ var Sender = /** @class */ (function (_super) {
                     _a[DisabledPropertyName] = true // Mark so we don't attempt to track this request
                 ,
                     _a);
-                if (!isAsync) {
+                if (sync) {
                     init.keepalive = true;
                     // As a sync request (during unload), it is unlikely that we will get a chance to process the response so
                     // just like beacon send assume that the events have been accepted and processed
@@ -736,8 +830,7 @@ var Sender = /** @class */ (function (_super) {
                     // If the environment has locked down the XMLHttpRequest (preventExtensions and/or freeze), this would
                     // cause the request to fail and we no telemetry would be sent
                 }
-                _self._buffer[_DYN_MARK_AS_SENT /* @min:%2emarkAsSent */](payload);
-                if (isAsync && _enableSendPromise) {
+                if (!sync && _enableSendPromise) {
                     thePromise = createPromise(function (resolve, reject) {
                         resolveFunc = resolve;
                         rejectFunc = reject;
@@ -745,7 +838,7 @@ var Sender = /** @class */ (function (_super) {
                 }
                 try {
                     doAwaitResponse(fetch(request), function (result) {
-                        if (!isAsync) {
+                        if (sync) {
                             _syncFetchPayload -= batchLength;
                             batchLength = 0;
                         }
@@ -759,18 +852,19 @@ var Sender = /** @class */ (function (_super) {
                                  * or if anything prevented the request from completing.
                                  */
                                 if (!response_1.ok) {
-                                    _self[_DYN__ON_ERROR /* @min:%2e_onError */](payload, response_1.statusText);
+                                    _doOnComplete(oncomplete, 400, {}, response_1.statusText);
                                     resolveFunc && resolveFunc(false);
                                 }
                                 else {
                                     doAwaitResponse(response_1.text(), function (resp) {
-                                        _checkResponsStatus(response_1.status, payload, response_1.url, payload[_DYN_LENGTH /* @min:%2elength */], response_1.statusText, resp.value || "");
+                                        var oriPayload = internalPayload[_DYN_ORI_PAYLOAD /* @min:%2eoriPayload */];
+                                        _checkResponsStatus(response_1.status, oriPayload, response_1.url, oriPayload[_DYN_LENGTH /* @min:%2elength */], response_1.statusText, resp.value || "");
                                         resolveFunc && resolveFunc(true);
                                     });
                                 }
                             }
                             else {
-                                _self[_DYN__ON_ERROR /* @min:%2e_onError */](payload, result.reason && result.reason.message);
+                                _doOnComplete(oncomplete, 400, {}, result.reason && result.reason.message);
                                 rejectFunc && rejectFunc(result.reason);
                             }
                         }
@@ -778,14 +872,14 @@ var Sender = /** @class */ (function (_super) {
                 }
                 catch (e) {
                     if (!responseHandled) {
-                        _self[_DYN__ON_ERROR /* @min:%2e_onError */](payload, dumpObj(e));
+                        _doOnComplete(oncomplete, 400, {}, dumpObj(e));
                         rejectFunc && rejectFunc(e);
                     }
                 }
                 if (ignoreResponse && !responseHandled) {
                     // Assume success during unload processing as we most likely won't get the response
                     responseHandled = true;
-                    _self._onSuccess(payload, payload[_DYN_LENGTH /* @min:%2elength */]);
+                    _doOnComplete(oncomplete, 200, {});
                     resolveFunc && resolveFunc(true);
                 }
                 return thePromise;
@@ -894,35 +988,39 @@ var Sender = /** @class */ (function (_super) {
             /**
              * Send XDomainRequest
              * @param payload - {string} - The data payload to be sent.
-             * @param isAsync - {boolean} - Indicates if the request should be sent asynchronously
+             * @param sync - {boolean} - Indicates if the request should be sent synchronously
              *
              * Note: XDomainRequest does not support sync requests. This 'isAsync' parameter is added
              * to maintain consistency with the xhrSender's contract
              * Note: XDomainRequest does not support custom headers and we are not able to get
              * appId from the backend for the correct correlation.
              */
-            function _xdrSender(payload, isAsync) {
-                var buffer = _self[_DYN__BUFFER /* @min:%2e_buffer */];
+            function _xdrSender(payload, oncomplete, sync) {
+                var internalPayload = payload;
                 var _window = getWindow();
                 var xdr = new XDomainRequest();
+                var data = internalPayload[_DYN_DATA /* @min:%2edata */];
                 // NOTE: xdr may send previous retry payload to new endpoint since we are not able to check response URL
-                xdr.onload = function () { return _self._xdrOnLoad(xdr, payload); };
-                xdr.onerror = function (event) { return _self[_DYN__ON_ERROR /* @min:%2e_onError */](payload, _formatErrorMessageXdr(xdr), event); };
+                xdr.onload = function () {
+                    var oriPayload = internalPayload[_DYN_ORI_PAYLOAD /* @min:%2eoriPayload */];
+                    // we will assume onload means the request succeeded.
+                    _self._xdrOnLoad(xdr, oriPayload);
+                };
+                xdr.onerror = function () {
+                    _doOnComplete(oncomplete, 400, {}, _formatErrorMessageXdr(xdr));
+                };
                 // XDomainRequest requires the same protocol as the hosting page.
                 // If the protocol doesn't match, we can't send the telemetry :(.
                 var hostingProtocol = _window && _window.location && _window.location.protocol || "";
                 if (_endpointUrl.lastIndexOf(hostingProtocol, 0) !== 0) {
                     _throwInternal(_self[_DYN_DIAG_LOG /* @min:%2ediagLog */](), 2 /* eLoggingSeverity.WARNING */, 40 /* _eInternalMessageId.TransmissionFailed */, ". " +
                         "Cannot send XDomain request. The endpoint URL protocol doesn't match the hosting page protocol.");
-                    buffer[_DYN_CLEAR /* @min:%2eclear */]();
+                    _self._buffer[_DYN_CLEAR /* @min:%2eclear */]();
                     return;
                 }
                 var endpointUrl = _endpointUrl.replace(/^(https?:)/, "");
                 xdr.open("POST", endpointUrl);
-                // compose an array of payloads
-                var batch = buffer[_DYN_BATCH_PAYLOADS /* @min:%2ebatchPayloads */](payload);
-                xdr.send(batch);
-                buffer[_DYN_MARK_AS_SENT /* @min:%2emarkAsSent */](payload);
+                xdr.send(data);
             }
             function _formatErrorMessageXdr(xdr, message) {
                 if (xdr) {
@@ -979,7 +1077,6 @@ var Sender = /** @class */ (function (_super) {
                 _serializer = null;
                 _stamp_specific_redirects = 0;
                 _syncFetchPayload = 0;
-                _fallbackSender = null;
                 _syncUnloadSender = null;
                 _evtNamespace = null;
                 _endpointUrl = null;
@@ -993,6 +1090,9 @@ var Sender = /** @class */ (function (_super) {
                 _isRetryDisabled = false;
                 _sessionStorageUsed = null;
                 _namePrefix = UNDEFINED_VALUE;
+                _disableXhr = false;
+                _fetchKeepAlive = false;
+                _xhrSend = null;
                 objDefine(_self, "_senderConfig", {
                     g: function () {
                         return objExtend({}, defaultAppInsightsChannelConfig);