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

package/dist/es5/applicationinsights-channel-js.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Channel, 3.0.4-nightly3.2309-09
+ * Application Insights JavaScript SDK - Channel, 3.0.4-nightly3.2309-10
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -1765,7 +1765,7 @@
         return result;
     }
 
-    var version = '3.0.4-nightly3.2309-09';
+    var version = '3.0.4-nightly3.2309-10';
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _canAcceptData(target) {
@@ -4663,6 +4663,7 @@
     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";
@@ -4670,21 +4671,22 @@
     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";
@@ -4799,7 +4801,7 @@
         }
     }
     var EnvelopeCreator = {
-        Version: '3.0.4-nightly3.2309-09'
+        Version: '3.0.4-nightly3.2309-10'
     };
     function DependencyEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
         EnvelopeCreatorInit(logger, telemetryItem);
@@ -5460,6 +5462,9 @@
         }
         return null;
     }
+    function isOverrideFn(httpXHROverride) {
+        return httpXHROverride && httpXHROverride[_DYN_SEND_POST ];
+    }
     var defaultAppInsightsChannelConfig = objDeepFreeze((_a = {
             endpointUrl: cfgDfValidate(isTruthy, DEFAULT_BREEZE_ENDPOINT + DEFAULT_BREEZE_PATH)
         },
@@ -5467,11 +5472,11 @@
         _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,
@@ -5480,6 +5485,8 @@
         _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;
@@ -5507,7 +5514,6 @@
             var _stamp_specific_redirects;
             var _headers;
             var _syncFetchPayload = 0;
-            var _fallbackSender;
             var _syncUnloadSender;
             var _offlineListener;
             var _evtNamespace;
@@ -5525,6 +5531,10 @@
             var _bufferOverrideUsed;
             var _namePrefix;
             var _enableSendPromise;
+            var _alwaysUseCustomSend;
+            var _disableXhr;
+            var _fetchKeepAlive;
+            var _xhrSend;
             dynamicProto(Sender, _this, function (_self, _base) {
                 _initDefaults();
                 _self.pause = function () {
@@ -5553,7 +5563,7 @@
                 };
                 _self.onunloadFlush = function () {
                     if (!_paused) {
-                        if (_beaconSupported) {
+                        if (_beaconSupported || _alwaysUseCustomSend) {
                             try {
                                 return _self[_DYN_TRIGGER_SEND ](true, _doUnloadSend, 2 );
                             }
@@ -5605,8 +5615,10 @@
                         }
                         _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)
@@ -5630,6 +5642,7 @@
                         _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)) {
@@ -5645,35 +5658,32 @@
                             _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;
@@ -5745,7 +5755,7 @@
                     }
                     _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);
                     }
@@ -5841,6 +5851,73 @@
                 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) {
@@ -5914,45 +5991,60 @@
                     }
                     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;
@@ -5963,7 +6055,7 @@
                     }
                     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 ]);
@@ -5972,51 +6064,52 @@
                         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;
@@ -6039,7 +6132,7 @@
                         _a[DisabledPropertyName] = true
                     ,
                         _a);
-                    if (!isAsync) {
+                    if (sync) {
                         init.keepalive = true;
                         ignoreResponse = true;
                         _syncFetchPayload += batchLength;
@@ -6050,8 +6143,7 @@
                     }
                     catch (e) {
                     }
-                    _self._buffer[_DYN_MARK_AS_SENT ](payload);
-                    if (isAsync && _enableSendPromise) {
+                    if (!sync && _enableSendPromise) {
                         thePromise = createPromise(function (resolve, reject) {
                             resolveFunc = resolve;
                             rejectFunc = reject;
@@ -6059,7 +6151,7 @@
                     }
                     try {
                         doAwaitResponse(fetch(request), function (result) {
-                            if (!isAsync) {
+                            if (sync) {
                                 _syncFetchPayload -= batchLength;
                                 batchLength = 0;
                             }
@@ -6068,18 +6160,19 @@
                                 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);
                                 }
                             }
@@ -6087,13 +6180,13 @@
                     }
                     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;
@@ -6176,24 +6269,28 @@
                     }
                     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) {
@@ -6243,7 +6340,6 @@
                     _serializer = null;
                     _stamp_specific_redirects = 0;
                     _syncFetchPayload = 0;
-                    _fallbackSender = null;
                     _syncUnloadSender = null;
                     _evtNamespace = null;
                     _endpointUrl = null;
@@ -6257,6 +6353,9 @@
                     _isRetryDisabled = false;
                     _sessionStorageUsed = null;
                     _namePrefix = UNDEFINED_VALUE;
+                    _disableXhr = false;
+                    _fetchKeepAlive = false;
+                    _xhrSend = null;
                     objDefine(_self, "_senderConfig", {
                         g: function () {
                             return objExtend({}, defaultAppInsightsChannelConfig);