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

package/browser/es5/{applicationinsights-channel-js.3.0.4-nightly3.2309-08.js → applicationinsights-channel-js.3.0.4-nightly3.2309-10.cjs.js}

@@ -1,32 +1,7 @@
 /*!
- * 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.
  */
-(function (global, factory) {
-    var undef = "undefined";
-    typeof exports === "object" && typeof module !== undef ? factory(exports) :
-    typeof define === "function" && define.amd ? define(["exports"], factory) :
-    (function(global){
-        var nsKey, key, nm, theExports = {}, modName = "es5_applicationinsights_channel_js_3_0_4_nightly3_2309_08", msMod="__ms$mod__";
-        var mods={}, modDetail=mods[modName]={}, ver="3.0.4-nightly3.2309-08";
-        var baseNs=global, nsKey="Microsoft", baseNs=baseNs[nsKey]=(baseNs[nsKey]||{});
-        // Versioned namespace "Microsoft.ApplicationInsights3"
-        var exportNs=baseNs, nsKey="ApplicationInsights3", exportNs=exportNs[nsKey]=(exportNs[nsKey]||{});
-        // Global namespace "Microsoft.ApplicationInsights"
-        var destNs=baseNs, nsKey="ApplicationInsights", destNs=destNs[nsKey]=(destNs[nsKey]||{});
-        var expNsDetail=(exportNs[msMod]=(exportNs[msMod] || {})), expNameVer=(expNsDetail["v"]=(expNsDetail["v"] || []));
-        var destNsDetail=(destNs[msMod]=(destNs[msMod] || {})), destNameVer=(destNsDetail["v"]=(destNsDetail["v"] || []));
-        (destNsDetail["o"]=(destNsDetail["o"] || [])).push(mods);
-        factory(theExports);
-        for(var key in theExports) {
-            // Always set the imported value into the "export" versioned namespace (last-write wins)
-            nm="x", exportNs[key]=theExports[key], expNameVer[key]=ver;
-            // Copy over any named element that is not already present (first-write wins)
-            typeof destNs[key]===undef ? (nm="n", destNs[key]=theExports[key]) && (destNameVer[key]=ver) : !destNameVer[key] && (destNameVer[key]="---");
-            (modDetail[nm] = (modDetail[nm] || [])).push(key);
-        }
-    })(typeof globalThis !== undef ? globalThis : global || self);
-})(this, (function (exports) {
 'use strict';
 
 
@@ -1787,7 +1762,7 @@ function newId(maxLength) {
     return result;
 }
 
-var version = '3.0.4-nightly3.2309-08';
+var version = '3.0.4-nightly3.2309-10';
 var instanceName = "." + newId(6);
 var _dataUid = 0;
 function _canAcceptData(target) {
@@ -4685,6 +4660,7 @@ var _DYN_BUFFER_OVERRIDE = "bufferOverride";
 var _DYN__BUFFER__KEY = "BUFFER_KEY";
 var _DYN__SENT__BUFFER__KEY = "SENT_BUFFER_KEY";
 var _DYN__MAX__BUFFER__SIZE = "MAX_BUFFER_SIZE";
+var _DYN_SEND_POST = "sendPOST";
 var _DYN_TRIGGER_SEND = "triggerSend";
 var _DYN_DIAG_LOG = "diagLog";
 var _DYN__SENDER = "_sender";
@@ -4692,21 +4668,22 @@ var _DYN_CUSTOM_HEADERS = "customHeaders";
 var _DYN_MAX_BATCH_SIZE_IN_BY1 = "maxBatchSizeInBytes";
 var _DYN_ONUNLOAD_DISABLE_BEA2 = "onunloadDisableBeacon";
 var _DYN_IS_BEACON_API_DISABL3 = "isBeaconApiDisabled";
-var _DYN_ENABLE_SESSION_STORA4 = "enableSessionStorageBuffer";
+var _DYN_ALWAYS_USE_XHR_OVERR4 = "alwaysUseXhrOverride";
+var _DYN_ENABLE_SESSION_STORA5 = "enableSessionStorageBuffer";
 var _DYN__BUFFER = "_buffer";
+var _DYN_ONUNLOAD_DISABLE_FET6 = "onunloadDisableFetch";
 var _DYN_INSTRUMENTATION_KEY = "instrumentationKey";
-var _DYN_DISABLE_XHR = "disableXhr";
-var _DYN_ONUNLOAD_DISABLE_FET5 = "onunloadDisableFetch";
 var _DYN_CONVERT_UNDEFINED = "convertUndefined";
 var _DYN_MAX_BATCH_INTERVAL = "maxBatchInterval";
 var _DYN_BASE_TYPE = "baseType";
 var _DYN_SAMPLE_RATE = "sampleRate";
-var _DYN__XHR_READY_STATE_CHA6 = "_xhrReadyStateChange";
+var _DYN__XHR_READY_STATE_CHA7 = "_xhrReadyStateChange";
 var _DYN__ON_ERROR = "_onError";
 var _DYN__ON_PARTIAL_SUCCESS = "_onPartialSuccess";
 var _DYN__ON_SUCCESS = "_onSuccess";
 var _DYN_ITEMS_ACCEPTED = "itemsAccepted";
 var _DYN_ITEMS_RECEIVED = "itemsReceived";
+var _DYN_ORI_PAYLOAD = "oriPayload";
 var _DYN_SET_REQUEST_HEADER = "setRequestHeader";
 var _DYN_EVENTS_SEND_REQUEST = "eventsSendRequest";
 var _DYN_GET_SAMPLING_SCORE = "getSamplingScore";
@@ -4821,7 +4798,7 @@ function EnvelopeCreatorInit(logger, telemetryItem) {
     }
 }
 var EnvelopeCreator = {
-    Version: '3.0.4-nightly3.2309-08'
+    Version: '3.0.4-nightly3.2309-10'
 };
 function DependencyEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
     EnvelopeCreatorInit(logger, telemetryItem);
@@ -5482,6 +5459,9 @@ function _getResponseText(xhr) {
     }
     return null;
 }
+function isOverrideFn(httpXHROverride) {
+    return httpXHROverride && httpXHROverride[_DYN_SEND_POST ];
+}
 var defaultAppInsightsChannelConfig = objDeepFreeze((_a = {
         endpointUrl: cfgDfValidate(isTruthy, DEFAULT_BREEZE_ENDPOINT + DEFAULT_BREEZE_PATH)
     },
@@ -5489,11 +5469,11 @@ var defaultAppInsightsChannelConfig = objDeepFreeze((_a = {
     _a[_DYN_MAX_BATCH_INTERVAL ] = 15000,
     _a[_DYN_MAX_BATCH_SIZE_IN_BY1 ] = 102400,
     _a.disableTelemetry = cfgDfBoolean(),
-    _a[_DYN_ENABLE_SESSION_STORA4 ] = cfgDfBoolean(true),
+    _a[_DYN_ENABLE_SESSION_STORA5 ] = cfgDfBoolean(true),
     _a.isRetryDisabled = cfgDfBoolean(),
     _a[_DYN_IS_BEACON_API_DISABL3 ] = cfgDfBoolean(true),
-    _a[_DYN_DISABLE_XHR ] = cfgDfBoolean(),
-    _a[_DYN_ONUNLOAD_DISABLE_FET5 ] = cfgDfBoolean(),
+    _a.disableXhr = cfgDfBoolean(),
+    _a[_DYN_ONUNLOAD_DISABLE_FET6 ] = cfgDfBoolean(),
     _a[_DYN_ONUNLOAD_DISABLE_BEA2 ] = cfgDfBoolean(),
     _a[_DYN_INSTRUMENTATION_KEY ] = UNDEFINED_VALUE,
     _a.namePrefix = UNDEFINED_VALUE,
@@ -5502,6 +5482,8 @@ var defaultAppInsightsChannelConfig = objDeepFreeze((_a = {
     _a[_DYN_CONVERT_UNDEFINED ] = UNDEFINED_VALUE,
     _a[_DYN_EVENTS_LIMIT_IN_MEM ] = 10000,
     _a[_DYN_BUFFER_OVERRIDE ] = false,
+    _a.httpXHROverride = { isVal: isOverrideFn, v: UNDEFINED_VALUE },
+    _a[_DYN_ALWAYS_USE_XHR_OVERR4 ] = cfgDfBoolean(),
     _a));
 function _chkSampling(value) {
     return !isNaN(value) && value > 0 && value <= 100;
@@ -5529,7 +5511,6 @@ var Sender = /** @class */ (function (_super) {
         var _stamp_specific_redirects;
         var _headers;
         var _syncFetchPayload = 0;
-        var _fallbackSender;
         var _syncUnloadSender;
         var _offlineListener;
         var _evtNamespace;
@@ -5547,6 +5528,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 () {
@@ -5575,7 +5560,7 @@ var Sender = /** @class */ (function (_super) {
             };
             _self.onunloadFlush = function () {
                 if (!_paused) {
-                    if (_beaconSupported) {
+                    if (_beaconSupported || _alwaysUseCustomSend) {
                         try {
                             return _self[_DYN_TRIGGER_SEND ](true, _doUnloadSend, 2 );
                         }
@@ -5627,8 +5612,10 @@ var Sender = /** @class */ (function (_super) {
                     }
                     _maxBatchSizeInBytes = senderConfig[_DYN_MAX_BATCH_SIZE_IN_BY1 ];
                     _beaconSupported = (senderConfig[_DYN_ONUNLOAD_DISABLE_BEA2 ] === false || senderConfig[_DYN_IS_BEACON_API_DISABL3 ] === false) && isBeaconsSupported();
+                    _alwaysUseCustomSend = senderConfig[_DYN_ALWAYS_USE_XHR_OVERR4 ];
+                    _disableXhr = !!senderConfig.disableXhr;
                     var bufferOverride = senderConfig[_DYN_BUFFER_OVERRIDE ];
-                    var canUseSessionStorage = !!senderConfig[_DYN_ENABLE_SESSION_STORA4 ] &&
+                    var canUseSessionStorage = !!senderConfig[_DYN_ENABLE_SESSION_STORA5 ] &&
                         (!!bufferOverride || utlCanUseSessionStorage());
                     var namePrefix = senderConfig.namePrefix;
                     var shouldUpdate = (canUseSessionStorage !== _sessionStorageUsed)
@@ -5652,6 +5639,7 @@ var Sender = /** @class */ (function (_super) {
                     _namePrefix = namePrefix;
                     _sessionStorageUsed = canUseSessionStorage;
                     _bufferOverrideUsed = bufferOverride;
+                    _fetchKeepAlive = !senderConfig[_DYN_ONUNLOAD_DISABLE_FET6 ] && isFetchSupported(true);
                     _self._sample = new Sample(senderConfig.samplingPercentage, diagLog);
                     _instrumentationKey = senderConfig[_DYN_INSTRUMENTATION_KEY ];
                     if (!_validateInstrumentationKey(_instrumentationKey, config)) {
@@ -5667,35 +5655,32 @@ var Sender = /** @class */ (function (_super) {
                         _customHeaders = null;
                     }
                     _enableSendPromise = senderConfig.enableSendPromise;
-                    var sendPostFunc = null;
-                    if (!senderConfig[_DYN_DISABLE_XHR ] && useXDomainRequest()) {
-                        sendPostFunc = _xdrSender;
-                    }
-                    else if (!senderConfig[_DYN_DISABLE_XHR ] && isXhrSupported()) {
-                        sendPostFunc = _xhrSender;
-                    }
-                    if (!sendPostFunc && isFetchSupported()) {
-                        sendPostFunc = _fetchSender;
-                    }
-                    _fallbackSender = sendPostFunc || _xhrSender;
+                    var customInterface = senderConfig.httpXHROverride;
+                    var httpInterface = null;
+                    var syncInterface = null;
+                    httpInterface = _getSenderInterface([1 , 2 ], false);
+                    var xhrInterface = { sendPOST: _xhrSender };
+                    _xhrSend = function (payload, isAsync) {
+                        return _doSend(xhrInterface, payload, isAsync);
+                    };
                     if (!senderConfig[_DYN_IS_BEACON_API_DISABL3 ] && isBeaconsSupported()) {
-                        sendPostFunc = _beaconSender;
+                        httpInterface = _getSenderInterface([3 ], false);
                     }
-                    _self[_DYN__SENDER ] = sendPostFunc || _xhrSender;
-                    if (!senderConfig[_DYN_ONUNLOAD_DISABLE_FET5 ] && isFetchSupported(true)) {
+                    httpInterface = _alwaysUseCustomSend ? customInterface : (httpInterface || customInterface || xhrInterface);
+                    _self[_DYN__SENDER ] = function (payload, isAsync) {
+                        return _doSend(httpInterface, payload, isAsync);
+                    };
+                    if (_fetchKeepAlive) {
                         _syncUnloadSender = _fetchKeepAliveSender;
                     }
-                    else if (isBeaconsSupported()) {
-                        _syncUnloadSender = _beaconSender;
+                    syncInterface = _alwaysUseCustomSend ? customInterface : (_getSenderInterface([3 , 1 ], true) || customInterface);
+                    if ((_alwaysUseCustomSend || !_syncUnloadSender) && syncInterface) {
+                        _syncUnloadSender = function (payload, isAsync) {
+                            return _doSend(syncInterface, payload, isAsync);
+                        };
                     }
-                    else if (!senderConfig[_DYN_DISABLE_XHR ] && useXDomainRequest()) {
-                        _syncUnloadSender = _xdrSender;
-                    }
-                    else if (!senderConfig[_DYN_DISABLE_XHR ] && isXhrSupported()) {
-                        _syncUnloadSender = _xhrSender;
-                    }
-                    else {
-                        _syncUnloadSender = _fallbackSender;
+                    if (!_syncUnloadSender) {
+                        _syncUnloadSender = _xhrSend;
                     }
                     _disableTelemetry = senderConfig.disableTelemetry;
                     _convertUndefined = senderConfig[_DYN_CONVERT_UNDEFINED ] || UNDEFINED_VALUE;
@@ -5767,7 +5752,7 @@ var Sender = /** @class */ (function (_super) {
                 }
                 _self.processNext(telemetryItem, itemCtx);
             };
-            _self[_DYN__XHR_READY_STATE_CHA6 ] = function (xhr, payload, countOfItemsInPayload) {
+            _self[_DYN__XHR_READY_STATE_CHA7 ] = function (xhr, payload, countOfItemsInPayload) {
                 if (xhr.readyState === 4) {
                     _checkResponsStatus(xhr.status, payload, xhr.responseURL, countOfItemsInPayload, _formatErrorMessageXhr(xhr), _getResponseText(xhr) || xhr.response);
                 }
@@ -5863,6 +5848,73 @@ 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 ]) {
+                    transportType = transports[lp];
+                    if (!_disableXhr && transportType === 1 ) {
+                        if (useXDomainRequest()) {
+                            sendPostFunc = _xdrSender;
+                        }
+                        else if (isXhrSupported()) {
+                            sendPostFunc = _xhrSender;
+                        }
+                    }
+                    else if (transportType === 2  && isFetchSupported(syncSupport)) {
+                        sendPostFunc = _fetchSender;
+                    }
+                    else if (isBeaconsSupported() && transportType === 3 ) {
+                        sendPostFunc = _beaconSender;
+                    }
+                    lp++;
+                }
+                if (sendPostFunc) {
+                    return _a = {},
+                        _a[_DYN_SEND_POST ] = sendPostFunc,
+                        _a;
+                }
+                return null;
+            }
+            function _getOnComplete(payload, status, headers, response) {
+                if (status === 200 && payload) {
+                    _self._onSuccess(payload, payload[_DYN_LENGTH ]);
+                }
+                response && _self[_DYN__ON_ERROR ](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 ];
+                if (sendPostFunc && payloadData) {
+                    _self._buffer[_DYN_MARK_AS_SENT ](payload);
+                    return sendPostFunc(payloadData, onComplete, !isAsync);
+                }
+                return null;
+            }
+            function _getPayload(payload) {
+                var _a;
+                if (isArray(payload) && payload[_DYN_LENGTH ] > 0) {
+                    var batch = _self._buffer[_DYN_BATCH_PAYLOADS ](payload);
+                    var payloadData = (_a = {},
+                        _a[_DYN_DATA ] = batch,
+                        _a.urlString = _endpointUrl,
+                        _a.headers = _headers,
+                        _a.disableXhrSync = _disableXhr,
+                        _a.disableFetchKeepAlive = !_fetchKeepAlive,
+                        _a[_DYN_ORI_PAYLOAD ] = payload,
+                        _a);
+                    return payloadData;
+                }
+                return null;
+            }
+            function _fetchSender(payload, oncomplete, sync) {
+                return _doFetchSender(payload, oncomplete, false);
+            }
             function _checkMaxSize(incomingPayload) {
                 var incomingSize = incomingPayload ? incomingPayload[_DYN_LENGTH ] : 0;
                 if ((_self[_DYN__BUFFER ].size() + incomingSize) > _maxBatchSizeInBytes) {
@@ -5936,45 +5988,60 @@ var Sender = /** @class */ (function (_super) {
                 }
                 return false;
             }
+            function _doOnComplete(oncomplete, status, headers, response) {
+                try {
+                    oncomplete(status, headers, response);
+                }
+                catch (e) {
+                }
+            }
             function _doUnloadSend(payload, isAsync) {
+                var onComplete = function (status, headers, response) {
+                    return _getOnComplete(payload, status, headers, response);
+                };
                 if (_syncUnloadSender) {
                     _syncUnloadSender(payload, false);
                 }
                 else {
-                    _beaconSender(payload);
+                    var payloadData = _getPayload(payload);
+                    _beaconSender(payloadData, onComplete);
                 }
             }
-            function _doBeaconSend(payload) {
+            function _doBeaconSend(payload, oncomplete) {
                 var nav = getNavigator();
-                var buffer = _self[_DYN__BUFFER ];
                 var url = _endpointUrl;
-                var batch = _self._buffer[_DYN_BATCH_PAYLOADS ](payload);
-                var plainTextBatch = new Blob([batch], { type: "text/plain;charset=UTF-8" });
+                var plainTextBatch = new Blob([payload], { type: "text/plain;charset=UTF-8" });
                 var queued = nav.sendBeacon(url, plainTextBatch);
                 if (queued) {
-                    buffer[_DYN_MARK_AS_SENT ](payload);
-                    _self._onSuccess(payload, payload[_DYN_LENGTH ]);
+                    oncomplete(200, {}, payload);
                 }
                 return queued;
             }
-            function _beaconSender(payload, isAsync) {
-                if (isArray(payload) && payload[_DYN_LENGTH ] > 0) {
-                    if (!_doBeaconSend(payload)) {
+            function _beaconSender(payload, oncomplete, sync) {
+                var internalPayload = payload;
+                var data = internalPayload && internalPayload[_DYN_DATA ];
+                if (isString(data) && data[_DYN_LENGTH ] > 0) {
+                    if (!_doBeaconSend(data, oncomplete)) {
                         var droppedPayload = [];
-                        for (var lp = 0; lp < payload[_DYN_LENGTH ]; lp++) {
-                            var thePayload = payload[lp];
-                            if (!_doBeaconSend([thePayload])) {
-                                droppedPayload[_DYN_PUSH ](thePayload);
+                        var oriPayload = internalPayload[_DYN_ORI_PAYLOAD ];
+                        if (oriPayload[_DYN_LENGTH ] > 0) {
+                            for (var lp = 0; lp < data[_DYN_LENGTH ]; lp++) {
+                                var thePayload = payload[lp];
+                                var batch = _self._buffer[_DYN_BATCH_PAYLOADS ](thePayload);
+                                if (!_doBeaconSend(batch, oncomplete)) {
+                                    droppedPayload[_DYN_PUSH ](thePayload);
+                                }
                             }
                         }
                         if (droppedPayload[_DYN_LENGTH ] > 0) {
-                            _fallbackSender && _fallbackSender(droppedPayload, true);
+                            _xhrSend && _xhrSend(droppedPayload, true);
                             _throwInternal(_self[_DYN_DIAG_LOG ](), 2 , 40 , ". " + "Failed to send telemetry with Beacon API, retried with normal sender.");
                         }
                     }
                 }
             }
-            function _xhrSender(payload, isAsync) {
+            function _xhrSender(payload, oncomplete, sync) {
+                var internalPayload = payload;
                 var thePromise;
                 var resolveFunc;
                 var rejectFunc;
@@ -5985,7 +6052,7 @@ var Sender = /** @class */ (function (_super) {
                 }
                 catch (e) {
                 }
-                xhr.open("POST", endPointUrl, isAsync);
+                xhr.open("POST", endPointUrl, !sync);
                 xhr[_DYN_SET_REQUEST_HEADER ]("Content-type", "application/json");
                 if (isInternalApplicationInsightsEndpoint(endPointUrl)) {
                     xhr[_DYN_SET_REQUEST_HEADER ](RequestHeaders[6 ], RequestHeaders[7 ]);
@@ -5994,51 +6061,52 @@ var Sender = /** @class */ (function (_super) {
                     xhr[_DYN_SET_REQUEST_HEADER ](headerName, _headers[headerName]);
                 });
                 xhr.onreadystatechange = function () {
-                    _self._xhrReadyStateChange(xhr, payload, payload[_DYN_LENGTH ]);
+                    var oriPayload = internalPayload[_DYN_ORI_PAYLOAD ];
+                    _self._xhrReadyStateChange(xhr, oriPayload, oriPayload[_DYN_LENGTH ]);
                     if (xhr.readyState === 4) {
                         resolveFunc && resolveFunc(true);
                     }
                 };
                 xhr.onerror = function (event) {
-                    _self[_DYN__ON_ERROR ](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;
                     });
                 }
-                var batch = _self._buffer[_DYN_BATCH_PAYLOADS ](payload);
-                xhr.send(batch);
-                _self._buffer[_DYN_MARK_AS_SENT ](payload);
+                xhr.send(payload[_DYN_DATA ]);
                 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 ];
                     for (var lp = 0; lp < payload[_DYN_LENGTH ]; lp++) {
                         payloadSize += payload[lp][_DYN_LENGTH ];
                     }
+                    var payloadData = _getPayload(payload);
                     if ((_syncFetchPayload + payloadSize) <= FetchSyncRequestSizeLimitBytes) {
-                        _doFetchSender(payload, false);
+                        _doFetchSender(payloadData, onComplete, true);
                     }
                     else if (isBeaconsSupported()) {
-                        _beaconSender(payload);
+                        _beaconSender(payloadData, onComplete);
                     }
                     else {
-                        _fallbackSender && _fallbackSender(payload, true);
+                        _xhrSend && _xhrSend(payload, true);
                         _throwInternal(_self[_DYN_DIAG_LOG ](), 2 , 40 , ". " + "Failed to send telemetry with Beacon API, retried with xhrSender.");
                     }
                 }
             }
-            function _fetchSender(payload, isAsync) {
-                return _doFetchSender(payload, true);
-            }
-            function _doFetchSender(payload, isAsync) {
+            function _doFetchSender(payload, oncomplete, sync) {
                 var _a;
                 var endPointUrl = _endpointUrl;
-                var batch = _self._buffer[_DYN_BATCH_PAYLOADS ](payload);
+                var internalPayload = payload;
+                var batch = internalPayload[_DYN_DATA ];
                 var plainTextBatch = new Blob([batch], { type: "application/json" });
                 var thePromise;
                 var resolveFunc;
@@ -6061,7 +6129,7 @@ var Sender = /** @class */ (function (_super) {
                     _a[DisabledPropertyName] = true
                 ,
                     _a);
-                if (!isAsync) {
+                if (sync) {
                     init.keepalive = true;
                     ignoreResponse = true;
                     _syncFetchPayload += batchLength;
@@ -6072,8 +6140,7 @@ var Sender = /** @class */ (function (_super) {
                 }
                 catch (e) {
                 }
-                _self._buffer[_DYN_MARK_AS_SENT ](payload);
-                if (isAsync && _enableSendPromise) {
+                if (!sync && _enableSendPromise) {
                     thePromise = createPromise(function (resolve, reject) {
                         resolveFunc = resolve;
                         rejectFunc = reject;
@@ -6081,7 +6148,7 @@ var Sender = /** @class */ (function (_super) {
                 }
                 try {
                     doAwaitResponse(fetch(request), function (result) {
-                        if (!isAsync) {
+                        if (sync) {
                             _syncFetchPayload -= batchLength;
                             batchLength = 0;
                         }
@@ -6090,18 +6157,19 @@ var Sender = /** @class */ (function (_super) {
                             if (!result.rejected) {
                                 var response_1 = result.value;
                                 if (!response_1.ok) {
-                                    _self[_DYN__ON_ERROR ](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 ], response_1.statusText, resp.value || "");
+                                        var oriPayload = internalPayload[_DYN_ORI_PAYLOAD ];
+                                        _checkResponsStatus(response_1.status, oriPayload, response_1.url, oriPayload[_DYN_LENGTH ], response_1.statusText, resp.value || "");
                                         resolveFunc && resolveFunc(true);
                                     });
                                 }
                             }
                             else {
-                                _self[_DYN__ON_ERROR ](payload, result.reason && result.reason.message);
+                                _doOnComplete(oncomplete, 400, {}, result.reason && result.reason.message);
                                 rejectFunc && rejectFunc(result.reason);
                             }
                         }
@@ -6109,13 +6177,13 @@ var Sender = /** @class */ (function (_super) {
                 }
                 catch (e) {
                     if (!responseHandled) {
-                        _self[_DYN__ON_ERROR ](payload, dumpObj(e));
+                        _doOnComplete(oncomplete, 400, {}, dumpObj(e));
                         rejectFunc && rejectFunc(e);
                     }
                 }
                 if (ignoreResponse && !responseHandled) {
                     responseHandled = true;
-                    _self._onSuccess(payload, payload[_DYN_LENGTH ]);
+                    _doOnComplete(oncomplete, 200, {});
                     resolveFunc && resolveFunc(true);
                 }
                 return thePromise;
@@ -6198,24 +6266,28 @@ var Sender = /** @class */ (function (_super) {
                 }
                 return message;
             }
-            function _xdrSender(payload, isAsync) {
-                var buffer = _self[_DYN__BUFFER ];
+            function _xdrSender(payload, oncomplete, sync) {
+                var internalPayload = payload;
                 var _window = getWindow();
                 var xdr = new XDomainRequest();
-                xdr.onload = function () { return _self._xdrOnLoad(xdr, payload); };
-                xdr.onerror = function (event) { return _self[_DYN__ON_ERROR ](payload, _formatErrorMessageXdr(xdr), event); };
+                var data = internalPayload[_DYN_DATA ];
+                xdr.onload = function () {
+                    var oriPayload = internalPayload[_DYN_ORI_PAYLOAD ];
+                    _self._xdrOnLoad(xdr, oriPayload);
+                };
+                xdr.onerror = function () {
+                    _doOnComplete(oncomplete, 400, {}, _formatErrorMessageXdr(xdr));
+                };
                 var hostingProtocol = _window && _window.location && _window.location.protocol || "";
                 if (_endpointUrl.lastIndexOf(hostingProtocol, 0) !== 0) {
                     _throwInternal(_self[_DYN_DIAG_LOG ](), 2 , 40 , ". " +
                         "Cannot send XDomain request. The endpoint URL protocol doesn't match the hosting page protocol.");
-                    buffer[_DYN_CLEAR ]();
+                    _self._buffer[_DYN_CLEAR ]();
                     return;
                 }
                 var endpointUrl = _endpointUrl.replace(/^(https?:)/, "");
                 xdr.open("POST", endpointUrl);
-                var batch = buffer[_DYN_BATCH_PAYLOADS ](payload);
-                xdr.send(batch);
-                buffer[_DYN_MARK_AS_SENT ](payload);
+                xdr.send(data);
             }
             function _formatErrorMessageXdr(xdr, message) {
                 if (xdr) {
@@ -6265,7 +6337,6 @@ var Sender = /** @class */ (function (_super) {
                 _serializer = null;
                 _stamp_specific_redirects = 0;
                 _syncFetchPayload = 0;
-                _fallbackSender = null;
                 _syncUnloadSender = null;
                 _evtNamespace = null;
                 _endpointUrl = null;
@@ -6279,6 +6350,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);
@@ -6303,6 +6377,4 @@ var Sender = /** @class */ (function (_super) {
 }(BaseTelemetryPlugin));
 
 exports.Sender = Sender;
-
-}));
-//# sourceMappingURL=applicationinsights-channel-js.3.0.4-nightly3.2309-08.js.map
+//# sourceMappingURL=applicationinsights-channel-js.3.0.4-nightly3.2309-10.cjs.js.map