@microsoft/applicationinsights-channel-js 3.1.1-nightly3.2402-22 → 3.1.1-nightly3.2403-02

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

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Channel, 3.1.1-nightly3.2402-22
+ * Application Insights JavaScript SDK - Channel, 3.1.1-nightly3.2403-02
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -1126,7 +1126,7 @@
     var _DYN_SPLICE = "splice";
     var _DYN_HDLR = "hdlr";
     var _DYN_CANCEL = "cancel";
-    var _DYN_INITIALIZE = "initialize";
+    var _DYN_INITIALIZE$1 = "initialize";
     var _DYN_IDENTIFIER = "identifier";
     var _DYN_IS_INITIALIZED = "isInitialized";
     var _DYN_GET_PLUGIN = "getPlugin";
@@ -1475,7 +1475,7 @@
     }
 
     var UNDEFINED_VALUE$1 = undefined;
-    var STR_EMPTY = "";
+    var STR_EMPTY$1 = "";
     var STR_CORE = "core";
     var STR_DISABLED = "disabled";
     var STR_EXTENSION_CONFIG = "extensionConfig";
@@ -1516,7 +1516,7 @@
         if (isError(object)) {
             return object[_DYN_NAME$2 ];
         }
-        return STR_EMPTY;
+        return STR_EMPTY$1;
     }
     function setValue(target, field, value, valChk, srcChk) {
         var theValue = value;
@@ -1620,6 +1620,7 @@
     }
 
     var strDocumentMode = "documentMode";
+    var strLocation = "location";
     var strConsole = "console";
     var strJSON = "JSON";
     var strCrypto = "crypto";
@@ -1629,6 +1630,7 @@
     var strXMLHttpRequest = "XMLHttpRequest";
     var _isTrident = null;
     var _navUserAgentCheck = null;
+    var _enableMocks = false;
     var _useXDomainRequest = null;
     var _beaconsSupported = null;
     function _hasProperty(theClass, property) {
@@ -1656,6 +1658,18 @@
         }
         return supported;
     }
+    function getLocation(checkForMock) {
+        if (checkForMock && _enableMocks) {
+            var mockLocation = getInst("__mockLocation");
+            if (mockLocation) {
+                return mockLocation;
+            }
+        }
+        if (typeof location === strShimObject && location) {
+            return location;
+        }
+        return getInst(strLocation);
+    }
     function getConsole() {
         if (typeof console !== strShimUndefined) {
             return console;
@@ -1681,7 +1695,7 @@
         var nav = getNavigator();
         if (nav && (nav[_DYN_USER_AGENT ] !== _navUserAgentCheck || _isTrident === null)) {
             _navUserAgentCheck = nav[_DYN_USER_AGENT ];
-            var userAgent = (_navUserAgentCheck || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ]();
+            var userAgent = (_navUserAgentCheck || STR_EMPTY$1)[_DYN_TO_LOWER_CASE$1 ]();
             _isTrident = (strContains(userAgent, strMsie) || strContains(userAgent, strTrident));
         }
         return _isTrident;
@@ -1690,9 +1704,9 @@
         if (userAgentStr === void 0) { userAgentStr = null; }
         if (!userAgentStr) {
             var navigator_1 = getNavigator() || {};
-            userAgentStr = navigator_1 ? (navigator_1.userAgent || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ]() : STR_EMPTY;
+            userAgentStr = navigator_1 ? (navigator_1.userAgent || STR_EMPTY$1)[_DYN_TO_LOWER_CASE$1 ]() : STR_EMPTY$1;
         }
-        var ua = (userAgentStr || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ]();
+        var ua = (userAgentStr || STR_EMPTY$1)[_DYN_TO_LOWER_CASE$1 ]();
         if (strContains(ua, strMsie)) {
             var doc = getDocument() || {};
             return Math.max(parseInt(ua[_DYN_SPLIT$1 ](strMsie)[1]), (doc[strDocumentMode] || 0));
@@ -1801,7 +1815,7 @@
         var base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
         var number = random32() >>> 0;
         var chars = 0;
-        var result = STR_EMPTY;
+        var result = STR_EMPTY$1;
         while (result[_DYN_LENGTH$2 ] < maxLength) {
             chars++;
             result += base64chars.charAt(number & 0x3F);
@@ -1839,11 +1853,11 @@
     }
     function createUniqueNamespace(name, includeVersion) {
         if (includeVersion === void 0) { includeVersion = false; }
-        return normalizeJsName(name + (_dataUid++) + (includeVersion ? "." + version : STR_EMPTY) + instanceName);
+        return normalizeJsName(name + (_dataUid++) + (includeVersion ? "." + version : STR_EMPTY$1) + instanceName);
     }
     function createElmNodeData(name) {
         var data = {
-            id: createUniqueNamespace("_aiData-" + (name || STR_EMPTY) + "." + version),
+            id: createUniqueNamespace("_aiData-" + (name || STR_EMPTY$1) + "." + version),
             accept: function (target) {
                 return _canAcceptData(target);
             },
@@ -2548,9 +2562,9 @@
         _a$2);
     function _sanitizeDiagnosticText(text) {
         if (text) {
-            return "\"" + text[_DYN_REPLACE ](/\"/g, STR_EMPTY) + "\"";
+            return "\"" + text[_DYN_REPLACE ](/\"/g, STR_EMPTY$1) + "\"";
         }
-        return STR_EMPTY;
+        return STR_EMPTY$1;
     }
     function _logToConsole(func, message) {
         var theConsole = getConsole();
@@ -2572,12 +2586,12 @@
             _self[_DYN_MESSAGE$1 ] =
                 (isUserAct ? AiUserActionablePrefix : AiNonUserActionablePrefix) +
                     msgId;
-            var strProps = STR_EMPTY;
+            var strProps = STR_EMPTY$1;
             if (hasJSON()) {
                 strProps = getJSON().stringify(properties);
             }
-            var diagnosticText = (msg ? " message:" + _sanitizeDiagnosticText(msg) : STR_EMPTY) +
-                (properties ? " props:" + _sanitizeDiagnosticText(strProps) : STR_EMPTY);
+            var diagnosticText = (msg ? " message:" + _sanitizeDiagnosticText(msg) : STR_EMPTY$1) +
+                (properties ? " props:" + _sanitizeDiagnosticText(strProps) : STR_EMPTY$1);
             _self[_DYN_MESSAGE$1 ] += diagnosticText;
         }
         _InternalLogMessage.dataType = "MessageData";
@@ -3110,7 +3124,7 @@
                 doPerf(itemCtx[STR_CORE ](), function () { return identifier + ":" + name; }, function () {
                     hasRunContext[chainId] = true;
                     try {
-                        var nextId = nextProxy ? nextProxy._id : STR_EMPTY;
+                        var nextId = nextProxy ? nextProxy._id : STR_EMPTY$1;
                         if (nextId) {
                             hasRunContext[nextId] = false;
                         }
@@ -3255,7 +3269,7 @@
             var _hookContainer;
             _initDefaults();
             dynamicProto(BaseTelemetryPlugin, _self, function (_self) {
-                _self[_DYN_INITIALIZE ] = function (config, core, extensions, pluginChain) {
+                _self[_DYN_INITIALIZE$1 ] = function (config, core, extensions, pluginChain) {
                     _setDefaults(config, core, pluginChain);
                     _isinitialized = true;
                 };
@@ -3396,16 +3410,16 @@
     var eventNamespace = /^([^.]*)(?:\.(.+)|)/;
     function _normalizeNamespace(name) {
         if (name && name[_DYN_REPLACE ]) {
-            return name[_DYN_REPLACE ](/^[\s\.]+|(?=[\s\.])[\.\s]+$/g, STR_EMPTY);
+            return name[_DYN_REPLACE ](/^[\s\.]+|(?=[\s\.])[\.\s]+$/g, STR_EMPTY$1);
         }
         return name;
     }
     function _getEvtNamespace(eventName, evtNamespace) {
         var _a;
         if (evtNamespace) {
-            var theNamespace_1 = STR_EMPTY;
+            var theNamespace_1 = STR_EMPTY$1;
             if (isArray(evtNamespace)) {
-                theNamespace_1 = STR_EMPTY;
+                theNamespace_1 = STR_EMPTY$1;
                 arrForEach(evtNamespace, function (name) {
                     name = _normalizeNamespace(name);
                     if (name) {
@@ -3423,13 +3437,13 @@
                 if (theNamespace_1[0] !== ".") {
                     theNamespace_1 = "." + theNamespace_1;
                 }
-                eventName = (eventName || STR_EMPTY) + theNamespace_1;
+                eventName = (eventName || STR_EMPTY$1) + theNamespace_1;
             }
         }
-        var parsedEvent = (eventNamespace.exec(eventName || STR_EMPTY) || []);
+        var parsedEvent = (eventNamespace.exec(eventName || STR_EMPTY$1) || []);
         return _a = {},
             _a[_DYN_TYPE ] = parsedEvent[1],
-            _a.ns = ((parsedEvent[2] || STR_EMPTY).replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, STR_EMPTY)[_DYN_SPLIT$1 ](".").sort()).join("."),
+            _a.ns = ((parsedEvent[2] || STR_EMPTY$1).replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, STR_EMPTY$1)[_DYN_SPLIT$1 ](".").sort()).join("."),
             _a;
     }
     function _getRegisteredEvents(target, evtName, addDefault) {
@@ -3578,14 +3592,20 @@
     var _DYN_SPLIT = "split";
     var _DYN_LENGTH$1 = "length";
     var _DYN_TO_LOWER_CASE = "toLowerCase";
+    var _DYN_LOCATION = "location";
     var _DYN_TO_STRING$1 = "toString";
     var _DYN_PUSH$1 = "push";
+    var _DYN_URL_STRING = "urlString";
+    var _DYN_DATA$1 = "data";
+    var _DYN_SET_REQUEST_HEADER = "setRequestHeader";
+    var _DYN_REASON = "reason";
+    var _DYN_MESSAGE = "message";
     var _DYN_REMOVE_ITEM = "removeItem";
     var _DYN_NAME$1 = "name";
-    var _DYN_MESSAGE = "message";
     var _DYN_COUNT$1 = "count";
     var _DYN_STRINGIFY$1 = "stringify";
     var _DYN_PATHNAME = "pathname";
+    var _DYN_ITEMS_RECEIVED$1 = "itemsReceived";
     var _DYN_EXCEPTIONS = "exceptions";
     var _DYN_PARSED_STACK = "parsedStack";
     var _DYN_PROPERTIES = "properties";
@@ -3807,6 +3827,54 @@
             data: data
         };
     }
+    function getResponseText(xhr) {
+        try {
+            return xhr.responseText;
+        }
+        catch (e) {
+        }
+        return null;
+    }
+    function formatErrorMessageXdr(xdr, message) {
+        if (xdr) {
+            return "XDomainRequest,Response:" + getResponseText(xdr) || "";
+        }
+        return message;
+    }
+    function formatErrorMessageXhr(xhr, message) {
+        if (xhr) {
+            return "XMLHttpRequest,Status:" + xhr.status + ",Response:" + getResponseText(xhr) || xhr.response || "";
+        }
+        return message;
+    }
+    function prependTransports(theTransports, newTransports) {
+        if (newTransports) {
+            if (isNumber(newTransports)) {
+                theTransports = [newTransports].concat(theTransports);
+            }
+            else if (isArray(newTransports)) {
+                theTransports = newTransports.concat(theTransports);
+            }
+        }
+        return theTransports;
+    }
+    function parseResponse(response, diagLog) {
+        try {
+            if (response && response !== "") {
+                var result = getJSON().parse(response);
+                if (result && result[_DYN_ITEMS_RECEIVED$1 ] && result[_DYN_ITEMS_RECEIVED$1 ] >= result.itemsAccepted &&
+                    result.itemsReceived - result.itemsAccepted === result.errors[_DYN_LENGTH$1 ]) {
+                    return result;
+                }
+            }
+        }
+        catch (e) {
+            _throwInternal(diagLog, 1 , 43 , "Cannot parse the response. " + getExceptionName(e), {
+                response: response
+            });
+        }
+        return null;
+    }
 
     var StorageType = createEnumStyle({
         LocalStorage: 0 ,
@@ -3885,7 +3953,7 @@
             _self.sampleRate = 100.0;
             _self.tags = {};
             _self[_DYN_NAME$1 ] = dataSanitizeString(logger, name) || strNotSpecified;
-            _self.data = data;
+            _self[_DYN_DATA$1 ] = data;
             _self.time = toISOString(new Date());
             _self.aiDataContract = {
                 time: 1 ,
@@ -4042,8 +4110,8 @@
                 else if (getWindow() && getWindow()["opera"] && errorObj[strMessage]) {
                     details = _getOperaStack(errorObj[_DYN_MESSAGE ]);
                 }
-                else if (errorObj["reason"] && errorObj.reason[strStack]) {
-                    details = _convertStackObj(errorObj.reason[strStack]);
+                else if (errorObj["reason"] && errorObj[_DYN_REASON ][strStack]) {
+                    details = _convertStackObj(errorObj[_DYN_REASON ][strStack]);
                 }
                 else if (isString(errorObj)) {
                     details = _convertStackObj(errorObj);
@@ -4514,7 +4582,7 @@
             _self.resultCode = resultCode + "";
             _self.type = dataSanitizeString(logger, requestAPI);
             var dependencyFields = AjaxHelperParseDependencyPath(logger, absoluteUrl, method, commandName);
-            _self.data = dataSanitizeUrl(logger, commandName) || dependencyFields.data;
+            _self[_DYN_DATA$1 ] = dataSanitizeUrl(logger, commandName) || dependencyFields[_DYN_DATA$1 ];
             _self.target = dataSanitizeString(logger, dependencyFields.target);
             if (correlationContext) {
                 _self.target = "".concat(_self.target, " | ").concat(correlationContext);
@@ -4680,6 +4748,360 @@
 
     var CtxTagKeys = new ContextTagKeys();
 
+    var STR_EMPTY = "";
+    var SenderPostManager = /** @class */ (function () {
+        function SenderPostManager() {
+            var _syncFetchPayload = 0;
+            var _enableSendPromise;
+            var _isInitialized;
+            var _diagLog;
+            var _isOneDs;
+            var _onCompleteFuncs;
+            var _disableCredentials;
+            var _fallbackInst;
+            var _disableXhr;
+            var _disableBeacon;
+            var _disableBeaconSync;
+            dynamicProto(SenderPostManager, this, function (_self, _base) {
+                var _sendCredentials = true;
+                _initDefaults();
+                _self.initialize = function (config, diagLog) {
+                    _diagLog = diagLog;
+                    if (_isInitialized) {
+                        _throwInternal(_diagLog, 1 , 28 , "Sender is already initialized");
+                    }
+                    _self.SetConfig(config);
+                    _isInitialized = true;
+                };
+                _self["_getDbgPlgTargets"] = function () {
+                    return [_isInitialized, _isOneDs, _disableCredentials, _enableSendPromise];
+                };
+                _self.SetConfig = function (config) {
+                    try {
+                        _onCompleteFuncs = config.senderOnCompleteCallBack || {};
+                        _disableCredentials = !!config.disableCredentials;
+                        _isOneDs = !!config.isOneDs;
+                        _enableSendPromise = !!config.enableSendPromise;
+                        _disableXhr = !!config.disableXhr;
+                        _disableBeacon = !!config.disableBeacon;
+                        _disableBeaconSync = !!config.disableBeaconSync;
+                        _fallbackInst = { sendPOST: _xhrSender };
+                        if (_disableCredentials) {
+                            var location_1 = getLocation();
+                            if (location_1 && location_1.protocol && location_1.protocol[_DYN_TO_LOWER_CASE ]() === "file:") {
+                                _sendCredentials = false;
+                            }
+                        }
+                        return true;
+                    }
+                    catch (e) {
+                    }
+                    return false;
+                };
+                _self.getSyncFetchPayload = function () {
+                    return _syncFetchPayload;
+                };
+                _self.getXhrInst = function (transports, sync) {
+                    if (transports && transports[_DYN_LENGTH$1 ]) {
+                        return _getSenderInterface(transports, sync);
+                    }
+                    return null;
+                };
+                _self.getFallbackInst = function () {
+                    return _fallbackInst;
+                };
+                _self._doTeardown = function (unloadCtx, unloadState) {
+                    _initDefaults();
+                };
+                function _onSuccess(res, onComplete) {
+                    _doOnComplete(onComplete, 200, {}, res);
+                }
+                function _onError(message, onComplete) {
+                    _throwInternal(_diagLog, 2 , 26 , "Failed to send telemetry.", { message: message });
+                    _doOnComplete(onComplete, 400, {});
+                }
+                function _onNoPayloadUrl(onComplete) {
+                    _onError("No endpoint url is provided for the batch", onComplete);
+                }
+                function _getSenderInterface(transports, syncSupport) {
+                    var transportType = null;
+                    var sendPostFunc = null;
+                    var lp = 0;
+                    while (sendPostFunc == null && lp < transports[_DYN_LENGTH$1 ]) {
+                        transportType = transports[lp];
+                        if (!_disableXhr && transportType === 1 ) {
+                            if (useXDomainRequest()) {
+                                sendPostFunc = _xdrSender;
+                            }
+                            else if (isXhrSupported()) {
+                                sendPostFunc = _xhrSender;
+                            }
+                        }
+                        else if (transportType === 2  && isFetchSupported(syncSupport)) {
+                            sendPostFunc = _doFetchSender;
+                        }
+                        else if (transportType === 3  && isBeaconsSupported() && (syncSupport ? !_disableBeaconSync : !_disableBeacon)) {
+                            sendPostFunc = _beaconSender;
+                        }
+                        lp++;
+                    }
+                    if (sendPostFunc) {
+                        return {
+                            sendPOST: sendPostFunc
+                        };
+                    }
+                    return null;
+                }
+                function _doOnComplete(oncomplete, status, headers, response) {
+                    try {
+                        oncomplete && oncomplete(status, headers, response);
+                    }
+                    catch (e) {
+                    }
+                }
+                function _doBeaconSend(payload, oncomplete) {
+                    var nav = getNavigator();
+                    var url = payload[_DYN_URL_STRING ];
+                    if (!url) {
+                        _onNoPayloadUrl(oncomplete);
+                        return true;
+                    }
+                    var data = payload[_DYN_DATA$1 ];
+                    var plainTextBatch = new Blob([data], { type: "text/plain;charset=UTF-8" });
+                    var queued = nav.sendBeacon(url, plainTextBatch);
+                    return queued;
+                }
+                function _beaconSender(payload, oncomplete, sync) {
+                    var data = payload[_DYN_DATA$1 ];
+                    if (data) {
+                        if (!_doBeaconSend(payload, oncomplete)) {
+                            var onRetry = _onCompleteFuncs && _onCompleteFuncs.beaconOnRetry;
+                            if (onRetry && isFunction(onRetry)) {
+                                onRetry(payload, oncomplete, _doBeaconSend);
+                            }
+                            else {
+                                _fallbackInst && _fallbackInst.sendPOST(payload, oncomplete, true);
+                                _throwInternal(_diagLog, 2 , 40 , ". " + "Failed to send telemetry with Beacon API, retried with normal sender.");
+                            }
+                        }
+                        else {
+                            _onSuccess(null, oncomplete);
+                        }
+                    }
+                    return;
+                }
+                function _xhrSender(payload, oncomplete, sync) {
+                    var thePromise;
+                    var resolveFunc;
+                    var rejectFunc;
+                    var headers = payload.headers || {};
+                    if (!sync && _enableSendPromise) {
+                        thePromise = createPromise(function (resolve, reject) {
+                            resolveFunc = resolve;
+                            rejectFunc = reject;
+                        });
+                    }
+                    var xhr = new XMLHttpRequest();
+                    var endPointUrl = payload[_DYN_URL_STRING ];
+                    if (!endPointUrl) {
+                        _onNoPayloadUrl(oncomplete);
+                        resolveFunc && resolveFunc(false);
+                        return;
+                    }
+                    try {
+                        xhr[DisabledPropertyName] = true;
+                    }
+                    catch (e) {
+                    }
+                    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 ]);
+                    }
+                    arrForEach(objKeys(headers), function (headerName) {
+                        xhr[_DYN_SET_REQUEST_HEADER ](headerName, headers[headerName]);
+                    });
+                    xhr.onreadystatechange = function () {
+                        var response = getResponseText(xhr);
+                        var onReadyFunc = _onCompleteFuncs && _onCompleteFuncs.xhrOnComplete;
+                        var onReadyFuncExist = onReadyFunc && isFunction(onReadyFunc);
+                        if (onReadyFuncExist) {
+                            onReadyFunc(xhr, oncomplete, payload);
+                        }
+                        if (xhr.readyState === 4) {
+                            if (!onReadyFuncExist) {
+                                _doOnComplete(oncomplete, xhr.status, {}, response);
+                            }
+                            resolveFunc && resolveFunc(true);
+                        }
+                    };
+                    xhr.onerror = function (event) {
+                        _doOnComplete(oncomplete, 400, {}, formatErrorMessageXhr(xhr));
+                        rejectFunc && rejectFunc(event);
+                    };
+                    xhr.ontimeout = function () {
+                        _doOnComplete(oncomplete, 500, {}, formatErrorMessageXhr(xhr));
+                        resolveFunc && resolveFunc(false);
+                    };
+                    xhr.send(payload[_DYN_DATA$1 ]);
+                    return thePromise;
+                }
+                function _doFetchSender(payload, oncomplete, sync) {
+                    var _a;
+                    var endPointUrl = payload[_DYN_URL_STRING ];
+                    var batch = payload[_DYN_DATA$1 ];
+                    var plainTextBatch = new Blob([batch], { type: "application/json" });
+                    var thePromise;
+                    var resolveFunc;
+                    var rejectFunc;
+                    var requestHeaders = new Headers();
+                    var batchLength = batch[_DYN_LENGTH$1 ];
+                    var ignoreResponse = false;
+                    var responseHandled = false;
+                    var headers = payload.headers || {};
+                    if (isInternalApplicationInsightsEndpoint(endPointUrl)) {
+                        requestHeaders.append(RequestHeaders[6 ], RequestHeaders[7 ]);
+                    }
+                    arrForEach(objKeys(headers), function (headerName) {
+                        requestHeaders.append(headerName, headers[headerName]);
+                    });
+                    var init = (_a = {
+                            method: "POST",
+                            headers: requestHeaders,
+                            body: plainTextBatch
+                        },
+                        _a[DisabledPropertyName] = true
+                    ,
+                        _a);
+                    if (_sendCredentials && _isOneDs) {
+                        init.credentials = "include";
+                    }
+                    if (sync) {
+                        init.keepalive = true;
+                        ignoreResponse = true;
+                        _syncFetchPayload += batchLength;
+                    }
+                    var request = new Request(endPointUrl, init);
+                    try {
+                        request[DisabledPropertyName] = true;
+                    }
+                    catch (e) {
+                    }
+                    if (!sync && _enableSendPromise) {
+                        thePromise = createPromise(function (resolve, reject) {
+                            resolveFunc = resolve;
+                            rejectFunc = reject;
+                        });
+                    }
+                    if (!endPointUrl) {
+                        _onNoPayloadUrl(oncomplete);
+                        resolveFunc && resolveFunc(false);
+                        return;
+                    }
+                    try {
+                        doAwaitResponse(fetch(request), function (result) {
+                            if (sync) {
+                                _syncFetchPayload -= batchLength;
+                                batchLength = 0;
+                            }
+                            if (!responseHandled) {
+                                responseHandled = true;
+                                if (!result.rejected) {
+                                    var response_1 = result.value;
+                                    if (!response_1.ok) {
+                                        _doOnComplete(oncomplete, 400, {}, response_1.statusText);
+                                        resolveFunc && resolveFunc(false);
+                                    }
+                                    else {
+                                        doAwaitResponse(response_1.text(), function (resp) {
+                                            var status = response_1.status;
+                                            var onCompleteFunc = _onCompleteFuncs.fetchOnComplete;
+                                            if (onCompleteFunc && isFunction(onCompleteFunc)) {
+                                                onCompleteFunc(response_1, oncomplete, resp.value || STR_EMPTY, payload);
+                                            }
+                                            else {
+                                                _doOnComplete(oncomplete, status, {}, resp.value || STR_EMPTY);
+                                            }
+                                            resolveFunc && resolveFunc(true);
+                                        });
+                                    }
+                                }
+                                else {
+                                    _doOnComplete(oncomplete, 400, {}, result[_DYN_REASON ] && result[_DYN_REASON ][_DYN_MESSAGE ]);
+                                    rejectFunc && rejectFunc(result[_DYN_REASON ]);
+                                }
+                            }
+                        });
+                    }
+                    catch (e) {
+                        if (!responseHandled) {
+                            _doOnComplete(oncomplete, 400, {}, dumpObj(e));
+                            rejectFunc && rejectFunc(e);
+                        }
+                    }
+                    if (ignoreResponse && !responseHandled) {
+                        responseHandled = true;
+                        _doOnComplete(oncomplete, 200, {});
+                        resolveFunc && resolveFunc(true);
+                    }
+                    return thePromise;
+                }
+                function _xdrSender(payload, oncomplete, sync) {
+                    var _window = getWindow();
+                    var xdr = new XDomainRequest();
+                    var data = payload[_DYN_DATA$1 ];
+                    xdr.onload = function () {
+                        var response = getResponseText(xdr);
+                        var onloadFunc = _onCompleteFuncs && _onCompleteFuncs.xdrOnComplete;
+                        if (onloadFunc && isFunction(onloadFunc)) {
+                            onloadFunc(xdr, oncomplete, payload);
+                        }
+                        else {
+                            _doOnComplete(oncomplete, 200, {}, response);
+                        }
+                    };
+                    xdr.onerror = function () {
+                        _doOnComplete(oncomplete, 400, {}, formatErrorMessageXdr(xdr));
+                    };
+                    xdr.ontimeout = function () {
+                        _doOnComplete(oncomplete, 500, {});
+                    };
+                    xdr.onprogress = function () { };
+                    var hostingProtocol = _window && _window[_DYN_LOCATION ] && _window[_DYN_LOCATION ].protocol || "";
+                    var endpoint = payload[_DYN_URL_STRING ];
+                    if (!endpoint) {
+                        _onNoPayloadUrl(oncomplete);
+                        return;
+                    }
+                    if (endpoint.lastIndexOf(hostingProtocol, 0) !== 0) {
+                        var msg = "Cannot send XDomain request. The endpoint URL protocol doesn't match the hosting page protocol.";
+                        _throwInternal(_diagLog, 2 , 40 , ". " + msg);
+                        _onError(msg, oncomplete);
+                        return;
+                    }
+                    var endpointUrl = endpoint.replace(/^(https?:)/, "");
+                    xdr.open("POST", endpointUrl);
+                    xdr.send(data);
+                }
+                function _initDefaults() {
+                    _syncFetchPayload = 0;
+                    _isInitialized = false;
+                    _enableSendPromise = false;
+                    _diagLog = null;
+                    _isOneDs = null;
+                    _onCompleteFuncs = null;
+                    _disableCredentials = null;
+                    _fallbackInst = null;
+                    _disableXhr = false;
+                    _disableBeacon = false;
+                    _disableBeaconSync = false;
+                }
+            });
+        }
+        SenderPostManager.__ieDyn=1;
+        return SenderPostManager;
+    }());
+
     function _disableEvents(target, evtNamespace) {
         eventOff(target, null, null, evtNamespace);
     }
@@ -4818,43 +5240,42 @@
     var _DYN_PUSH = "push";
     var _DYN_EMIT_LINE_DELIMITED_0 = "emitLineDelimitedJson";
     var _DYN_CLEAR = "clear";
-    var _DYN_BATCH_PAYLOADS = "batchPayloads";
     var _DYN_CREATE_NEW = "createNew";
     var _DYN_MARK_AS_SENT = "markAsSent";
     var _DYN_CLEAR_SENT = "clearSent";
     var _DYN_BUFFER_OVERRIDE = "bufferOverride";
     var _DYN__BUFFER__KEY = "BUFFER_KEY";
     var _DYN__SENT__BUFFER__KEY = "SENT_BUFFER_KEY";
-    var _DYN_CONCAT = "concat";
     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_INITIALIZE = "initialize";
     var _DYN__SENDER = "_sender";
     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_ALWAYS_USE_XHR_OVERR4 = "alwaysUseXhrOverride";
+    var _DYN_DISABLE_XHR = "disableXhr";
     var _DYN_ENABLE_SESSION_STORA5 = "enableSessionStorageBuffer";
     var _DYN__BUFFER = "_buffer";
     var _DYN_ONUNLOAD_DISABLE_FET6 = "onunloadDisableFetch";
     var _DYN_DISABLE_SEND_BEACON_7 = "disableSendBeaconSplit";
     var _DYN_INSTRUMENTATION_KEY = "instrumentationKey";
+    var _DYN_ENABLE_SEND_PROMISE = "enableSendPromise";
+    var _DYN_GET_XHR_INST = "getXhrInst";
     var _DYN_UNLOAD_TRANSPORTS = "unloadTransports";
     var _DYN_CONVERT_UNDEFINED = "convertUndefined";
     var _DYN_MAX_BATCH_INTERVAL = "maxBatchInterval";
     var _DYN_SERIALIZE = "serialize";
-    var _DYN__XHR_READY_STATE_CHA8 = "_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_BASE_TYPE = "baseType";
     var _DYN_SAMPLE_RATE = "sampleRate";
-    var _DYN_ORI_PAYLOAD = "oriPayload";
-    var _DYN_SET_REQUEST_HEADER = "setRequestHeader";
     var _DYN_EVENTS_SEND_REQUEST = "eventsSendRequest";
     var _DYN_GET_SAMPLING_SCORE = "getSamplingScore";
     var _DYN_GET_HASH_CODE_SCORE = "getHashCodeScore";
@@ -4968,7 +5389,7 @@
         }
     }
     var EnvelopeCreator = {
-        Version: '3.1.1-nightly3.2402-22'
+        Version: '3.1.1-nightly3.2403-02'
     };
     function DependencyEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
         EnvelopeCreatorInit(logger, telemetryItem);
@@ -5159,7 +5580,7 @@
                 _self.getItems = function () {
                     return _buffer.slice(0);
                 };
-                _self[_DYN_BATCH_PAYLOADS ] = function (payload) {
+                _self.batchPayloads = function (payload) {
                     if (payload && payload[_DYN_LENGTH ] > 0) {
                         var batch = config[_DYN_EMIT_LINE_DELIMITED_0 ] ?
                             payload.join("\n") :
@@ -5209,7 +5630,7 @@
             dynamicProto(SessionStorageSendBuffer, _this, function (_self, _base) {
                 var bufferItems = _getBuffer(SessionStorageSendBuffer[_DYN__BUFFER__KEY ]);
                 var notDeliveredItems = _getBuffer(SessionStorageSendBuffer[_DYN__SENT__BUFFER__KEY ]);
-                var buffer = _self._set(bufferItems[_DYN_CONCAT ](notDeliveredItems));
+                var buffer = _self._set(bufferItems.concat(notDeliveredItems));
                 if (buffer[_DYN_LENGTH ] > SessionStorageSendBuffer[_DYN__MAX__BUFFER__SIZE ]) {
                     buffer[_DYN_LENGTH ] = SessionStorageSendBuffer[_DYN__MAX__BUFFER__SIZE ];
                 }
@@ -5236,7 +5657,7 @@
                     _setBuffer(SessionStorageSendBuffer[_DYN__BUFFER__KEY ], _self._set(_removePayloadsFromBuffer(payload, _self[_DYN__GET ]())));
                     var sentElements = _getBuffer(SessionStorageSendBuffer[_DYN__SENT__BUFFER__KEY ]);
                     if (sentElements instanceof Array && payload instanceof Array) {
-                        sentElements = sentElements[_DYN_CONCAT ](payload);
+                        sentElements = sentElements.concat(payload);
                         if (sentElements[_DYN_LENGTH ] > SessionStorageSendBuffer[_DYN__MAX__BUFFER__SIZE ]) {
                             _throwInternal(logger, 1 , 67 , "Sent buffer reached its maximum size: " + sentElements[_DYN_LENGTH ], true);
                             sentElements[_DYN_LENGTH ] = SessionStorageSendBuffer[_DYN__MAX__BUFFER__SIZE ];
@@ -5469,7 +5890,7 @@
                 return 0;
             }
             while (input[_DYN_LENGTH ] < MIN_INPUT_LENGTH) {
-                input = input[_DYN_CONCAT ](input);
+                input = input.concat(input);
             }
             var hash = 5381;
             for (var i = 0; i < input[_DYN_LENGTH ]; ++i) {
@@ -5549,18 +5970,7 @@
         return null;
     }
     function isOverrideFn(httpXHROverride) {
-        return httpXHROverride && httpXHROverride[_DYN_SEND_POST ];
-    }
-    function _prependTransports(theTransports, newTransports) {
-        if (newTransports) {
-            if (isNumber(newTransports)) {
-                theTransports = [newTransports][_DYN_CONCAT ](theTransports);
-            }
-            else if (isArray(newTransports)) {
-                theTransports = newTransports[_DYN_CONCAT ](theTransports);
-            }
-        }
-        return theTransports;
+        return httpXHROverride && httpXHROverride.sendPOST;
     }
     var defaultAppInsightsChannelConfig = objDeepFreeze((_a = {
             endpointUrl: cfgDfValidate(isTruthy, DEFAULT_BREEZE_ENDPOINT + DEFAULT_BREEZE_PATH)
@@ -5573,7 +5983,7 @@
         _a.isRetryDisabled = cfgDfBoolean(),
         _a[_DYN_IS_BEACON_API_DISABL3 ] = cfgDfBoolean(true),
         _a[_DYN_DISABLE_SEND_BEACON_7 ] = cfgDfBoolean(true),
-        _a.disableXhr = cfgDfBoolean(),
+        _a[_DYN_DISABLE_XHR ] = cfgDfBoolean(),
         _a[_DYN_ONUNLOAD_DISABLE_FET6 ] = cfgDfBoolean(),
         _a[_DYN_ONUNLOAD_DISABLE_BEA2 ] = cfgDfBoolean(),
         _a[_DYN_INSTRUMENTATION_KEY ] = UNDEFINED_VALUE,
@@ -5638,6 +6048,7 @@
             var _xhrSend;
             var _fallbackSend;
             var _disableBeaconSplit;
+            var _sendPostMgr;
             dynamicProto(Sender, _this, function (_self, _base) {
                 _initDefaults();
                 _self.pause = function () {
@@ -5682,11 +6093,11 @@
                 _self.addHeader = function (name, value) {
                     _headers[name] = value;
                 };
-                _self.initialize = function (config, core, extensions, pluginChain) {
+                _self[_DYN_INITIALIZE ] = function (config, core, extensions, pluginChain) {
                     if (_self.isInitialized()) {
                         _throwInternal(_self[_DYN_DIAG_LOG ](), 1 , 28 , "Sender is already initialized");
                     }
-                    _base.initialize(config, core, extensions, pluginChain);
+                    _base[_DYN_INITIALIZE ](config, core, extensions, pluginChain);
                     var identifier = _self.identifier;
                     _serializer = new Serializer(core.logger);
                     _consecutiveErrors = 0;
@@ -5721,7 +6132,7 @@
                         _beaconOnUnloadSupported = senderConfig[_DYN_ONUNLOAD_DISABLE_BEA2 ] === false && isBeaconsSupported();
                         _beaconNormalSupported = senderConfig[_DYN_IS_BEACON_API_DISABL3 ] === false && isBeaconsSupported();
                         _alwaysUseCustomSend = senderConfig[_DYN_ALWAYS_USE_XHR_OVERR4 ];
-                        _disableXhr = !!senderConfig.disableXhr;
+                        _disableXhr = !!senderConfig[_DYN_DISABLE_XHR ];
                         var bufferOverride = senderConfig[_DYN_BUFFER_OVERRIDE ];
                         var canUseSessionStorage = !!senderConfig[_DYN_ENABLE_SESSION_STORA5 ] &&
                             (!!bufferOverride || utlCanUseSessionStorage());
@@ -5763,13 +6174,21 @@
                         else {
                             _customHeaders = null;
                         }
-                        _enableSendPromise = senderConfig.enableSendPromise;
+                        _enableSendPromise = senderConfig[_DYN_ENABLE_SEND_PROMISE ];
+                        var sendPostConfig = _getSendPostMgrConfig();
+                        if (!_sendPostMgr) {
+                            _sendPostMgr = new SenderPostManager();
+                            _sendPostMgr[_DYN_INITIALIZE ](sendPostConfig, diagLog);
+                        }
+                        else {
+                            _sendPostMgr.SetConfig(sendPostConfig);
+                        }
                         var customInterface = senderConfig.httpXHROverride;
                         var httpInterface = null;
                         var syncInterface = null;
-                        var theTransports = _prependTransports([3 , 1 , 2 ], senderConfig.transports);
-                        httpInterface = _getSenderInterface(theTransports, false);
-                        var xhrInterface = { sendPOST: _xhrSender };
+                        var theTransports = prependTransports([3 , 1 , 2 ], senderConfig.transports);
+                        httpInterface = _sendPostMgr && _sendPostMgr[_DYN_GET_XHR_INST ](theTransports, false);
+                        var xhrInterface = _sendPostMgr && _sendPostMgr.getFallbackInst();
                         _xhrSend = function (payload, isAsync) {
                             return _doSend(xhrInterface, payload, isAsync);
                         };
@@ -5783,11 +6202,11 @@
                         if (_fetchKeepAlive) {
                             _syncUnloadSender = _fetchKeepAliveSender;
                         }
-                        var syncTransports = _prependTransports([3 , 1 ], senderConfig[_DYN_UNLOAD_TRANSPORTS ]);
+                        var syncTransports = prependTransports([3 , 1 ], senderConfig[_DYN_UNLOAD_TRANSPORTS ]);
                         if (!_fetchKeepAlive) {
                             syncTransports = syncTransports.filter(function (transport) { return transport !== 2 ; });
                         }
-                        syncInterface = _getSenderInterface(syncTransports, true);
+                        syncInterface = _sendPostMgr && _sendPostMgr[_DYN_GET_XHR_INST ](syncTransports, true);
                         syncInterface = _alwaysUseCustomSend ? customInterface : (syncInterface || customInterface);
                         if ((_alwaysUseCustomSend || senderConfig[_DYN_UNLOAD_TRANSPORTS ] || !_syncUnloadSender) && syncInterface) {
                             _syncUnloadSender = function (payload, isAsync) {
@@ -5829,10 +6248,8 @@
                 _self.isCompletelyIdle = function () {
                     return !_paused && _syncFetchPayload === 0 && _self._buffer[_DYN_COUNT ]() === 0;
                 };
-                _self[_DYN__XHR_READY_STATE_CHA8 ] = function (xhr, payload, countOfItemsInPayload) {
-                    if (xhr.readyState === 4) {
-                        _checkResponsStatus(xhr.status, payload, xhr.responseURL, countOfItemsInPayload, _formatErrorMessageXhr(xhr), _getResponseText(xhr) || xhr.response);
-                    }
+                _self._xhrReadyStateChange = function (xhr, payload, countOfItemsInPayload) {
+                    return _xhrReadyStateChange(xhr, payload, countOfItemsInPayload);
                 };
                 _self[_DYN_TRIGGER_SEND ] = function (async, forcedSender, sendReason) {
                     if (async === void 0) { async = true; }
@@ -5908,7 +6325,7 @@
                         _self[_DYN__ON_SUCCESS ](payload, results[_DYN_ITEMS_ACCEPTED ]);
                     }
                     if (failed[_DYN_LENGTH ] > 0) {
-                        _self[_DYN__ON_ERROR ](failed, _formatErrorMessageXhr(null, ["partial success", results[_DYN_ITEMS_ACCEPTED ], "of", results.itemsReceived].join(" ")));
+                        _self[_DYN__ON_ERROR ](failed, formatErrorMessageXhr(null, ["partial success", results[_DYN_ITEMS_ACCEPTED ], "of", results.itemsReceived].join(" ")));
                     }
                     if (retry[_DYN_LENGTH ] > 0) {
                         _resendPayload(retry);
@@ -5921,22 +6338,89 @@
                     _self._buffer && _self._buffer[_DYN_CLEAR_SENT ](payload);
                 };
                 _self._xdrOnLoad = function (xdr, payload) {
+                    return _xdrOnLoad(xdr, payload);
+                };
+                function _xdrOnLoad(xdr, payload) {
                     var responseText = _getResponseText(xdr);
                     if (xdr && (responseText + "" === "200" || responseText === "")) {
                         _consecutiveErrors = 0;
                         _self[_DYN__ON_SUCCESS ](payload, 0);
                     }
                     else {
-                        var results = _parseResponse(responseText);
+                        var results = parseResponse(responseText);
                         if (results && results.itemsReceived && results.itemsReceived > results[_DYN_ITEMS_ACCEPTED ]
                             && !_isRetryDisabled) {
                             _self[_DYN__ON_PARTIAL_SUCCESS ](payload, results);
                         }
                         else {
-                            _self[_DYN__ON_ERROR ](payload, _formatErrorMessageXdr(xdr));
+                            _self[_DYN__ON_ERROR ](payload, formatErrorMessageXdr(xdr));
                         }
                     }
-                };
+                }
+                function _getSendPostMgrConfig() {
+                    var _a;
+                    try {
+                        var onCompleteFuncs = {
+                            xdrOnComplete: function (xdr, oncomplete, payload) {
+                                var data = _getPayloadArr(payload);
+                                if (!data) {
+                                    return;
+                                }
+                                return _xdrOnLoad(xdr, data);
+                            },
+                            fetchOnComplete: function (response, onComplete, resValue, payload) {
+                                var data = _getPayloadArr(payload);
+                                if (!data) {
+                                    return;
+                                }
+                                return _checkResponsStatus(response.status, data, response.url, data[_DYN_LENGTH ], response.statusText, resValue || "");
+                            },
+                            xhrOnComplete: function (request, oncomplete, payload) {
+                                var data = _getPayloadArr(payload);
+                                if (!data) {
+                                    return;
+                                }
+                                return _xhrReadyStateChange(request, data, data[_DYN_LENGTH ]);
+                            },
+                            beaconOnRetry: function (data, onComplete, canSend) {
+                                return _onBeaconRetry(data, onComplete, canSend);
+                            }
+                        };
+                        var config = (_a = {},
+                            _a[_DYN_ENABLE_SEND_PROMISE ] = _enableSendPromise,
+                            _a.isOneDs = false,
+                            _a.disableCredentials = false,
+                            _a[_DYN_DISABLE_XHR ] = _disableXhr,
+                            _a.disableBeacon = !_beaconNormalSupported,
+                            _a.disableBeaconSync = !_beaconOnUnloadSupported,
+                            _a.senderOnCompleteCallBack = onCompleteFuncs,
+                            _a);
+                        return config;
+                    }
+                    catch (e) {
+                    }
+                    return null;
+                }
+                function _xhrReadyStateChange(xhr, payload, countOfItemsInPayload) {
+                    if (xhr.readyState === 4) {
+                        _checkResponsStatus(xhr.status, payload, xhr.responseURL, countOfItemsInPayload, formatErrorMessageXhr(xhr), _getResponseText(xhr) || xhr.response);
+                    }
+                }
+                function _getPayloadArr(payload) {
+                    try {
+                        if (payload) {
+                            var internalPayload = payload;
+                            var arr = internalPayload[_DYN_ORI_PAYLOAD ];
+                            if (arr && arr[_DYN_LENGTH ]) {
+                                return arr;
+                            }
+                            return null;
+                        }
+                    }
+                    catch (e) {
+                    }
+                    return null;
+                }
                 function _validate(telemetryItem, diagLogger) {
                     if (_disableTelemetry) {
                         return false;
@@ -6032,36 +6516,6 @@
                 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 (transportType === 3  && (syncSupport ? _beaconOnUnloadSupported : _beaconNormalSupported)) {
-                            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 ]);
@@ -6076,7 +6530,7 @@
                         return _getOnComplete(payload, status, headers, response);
                     };
                     var payloadData = _getPayload(payload);
-                    var sendPostFunc = sendInterface && sendInterface[_DYN_SEND_POST ];
+                    var sendPostFunc = sendInterface && sendInterface.sendPOST;
                     if (sendPostFunc && payloadData) {
                         if (markAsSent) {
                             _self._buffer[_DYN_MARK_AS_SENT ](payload);
@@ -6088,7 +6542,7 @@
                 function _getPayload(payload) {
                     var _a;
                     if (isArray(payload) && payload[_DYN_LENGTH ] > 0) {
-                        var batch = _self._buffer[_DYN_BATCH_PAYLOADS ](payload);
+                        var batch = _self[_DYN__BUFFER ].batchPayloads(payload);
                         var payloadData = (_a = {},
                             _a[_DYN_DATA ] = batch,
                             _a.urlString = _endpointUrl,
@@ -6101,9 +6555,6 @@
                     }
                     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) {
@@ -6117,7 +6568,7 @@
                 function _checkResponsStatus(status, payload, responseUrl, countOfItemsInPayload, errorMessage, res) {
                     var response = null;
                     if (!_self._appId) {
-                        response = _parseResponse(res);
+                        response = parseResponse(res);
                         if (response && response.appId) {
                             _self._appId = response.appId;
                         }
@@ -6149,7 +6600,7 @@
                         _checkAndUpdateEndPointUrl(responseUrl);
                         if (status === 206) {
                             if (!response) {
-                                response = _parseResponse(res);
+                                response = parseResponse(res);
                             }
                             if (response && !_isRetryDisabled) {
                                 _self[_DYN__ON_PARTIAL_SUCCESS ](payload, response);
@@ -6177,223 +6628,61 @@
                     }
                     return false;
                 }
-                function _doOnComplete(oncomplete, status, headers, response) {
-                    try {
-                        oncomplete(status, headers, response);
-                    }
-                    catch (e) {
-                    }
-                }
                 function _doUnloadSend(payload, isAsync) {
                     if (_syncUnloadSender) {
                         _syncUnloadSender(payload, false);
                     }
                     else {
-                        var payloadData = _getPayload(payload);
-                        _self._buffer[_DYN_MARK_AS_SENT ](payload);
-                        _beaconSender(payloadData);
+                        var beaconInst = _sendPostMgr && _sendPostMgr[_DYN_GET_XHR_INST ]([3 ], true);
+                        return _doSend(beaconInst, payload, isAsync);
                     }
                 }
-                function _doBeaconSend(payload, oncomplete) {
-                    var nav = getNavigator();
-                    var url = _endpointUrl;
-                    var buffer = _self[_DYN__BUFFER ];
-                    var batch = buffer[_DYN_BATCH_PAYLOADS ](payload);
-                    var plainTextBatch = new Blob([batch], { type: "text/plain;charset=UTF-8" });
-                    var queued = nav.sendBeacon(url, plainTextBatch);
-                    if (queued) {
-                        _self._onSuccess(payload, payload[_DYN_LENGTH ]);
-                    }
-                    return queued;
-                }
-                function _beaconSender(payload, oncomplete, sync) {
+                function _onBeaconRetry(payload, onComplete, canSend) {
                     var internalPayload = payload;
                     var data = internalPayload && internalPayload[_DYN_ORI_PAYLOAD ];
-                    if (isArray(data) && data[_DYN_LENGTH ] > 0) {
-                        if (!_doBeaconSend(data)) {
-                            if (!_disableBeaconSplit) {
-                                var droppedPayload = [];
-                                for (var lp = 0; lp < data[_DYN_LENGTH ]; lp++) {
-                                    var thePayload = data[lp];
-                                    if (!_doBeaconSend([thePayload])) {
-                                        droppedPayload[_DYN_PUSH ](thePayload);
-                                    }
-                                }
-                                if (droppedPayload[_DYN_LENGTH ] > 0) {
-                                    _fallbackSend && _fallbackSend(droppedPayload, true);
-                                    _throwInternal(_self[_DYN_DIAG_LOG ](), 2 , 40 , ". " + "Failed to send telemetry with Beacon API, retried with normal sender.");
-                                }
+                    if (!_disableBeaconSplit) {
+                        var droppedPayload = [];
+                        for (var lp = 0; lp < data[_DYN_LENGTH ]; lp++) {
+                            var thePayload = data[lp];
+                            var arr = [thePayload];
+                            var item = _getPayload(arr);
+                            if (!canSend(item, onComplete)) {
+                                droppedPayload[_DYN_PUSH ](thePayload);
                             }
                             else {
-                                _fallbackSend && _fallbackSend(data, true);
-                                _throwInternal(_self[_DYN_DIAG_LOG ](), 2 , 40 , ". " + "Failed to send telemetry with Beacon API, retried with normal sender.");
+                                _self._onSuccess(arr, arr[_DYN_LENGTH ]);
                             }
                         }
-                    }
-                }
-                function _xhrSender(payload, oncomplete, sync) {
-                    var internalPayload = payload;
-                    var thePromise;
-                    var resolveFunc;
-                    var rejectFunc;
-                    var xhr = new XMLHttpRequest();
-                    var endPointUrl = _endpointUrl;
-                    try {
-                        xhr[DisabledPropertyName] = true;
-                    }
-                    catch (e) {
-                    }
-                    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 ]);
-                    }
-                    arrForEach(objKeys(_headers), function (headerName) {
-                        xhr[_DYN_SET_REQUEST_HEADER ](headerName, _headers[headerName]);
-                    });
-                    xhr.onreadystatechange = function () {
-                        var oriPayload = internalPayload[_DYN_ORI_PAYLOAD ];
-                        _self._xhrReadyStateChange(xhr, oriPayload, oriPayload[_DYN_LENGTH ]);
-                        if (xhr.readyState === 4) {
-                            resolveFunc && resolveFunc(true);
+                        if (droppedPayload[_DYN_LENGTH ] > 0) {
+                            _fallbackSend && _fallbackSend(droppedPayload, true);
+                            _throwInternal(_self[_DYN_DIAG_LOG ](), 2 , 40 , ". " + "Failed to send telemetry with Beacon API, retried with normal sender.");
                         }
-                    };
-                    xhr.onerror = function (event) {
-                        _doOnComplete(oncomplete, 400, {}, _formatErrorMessageXhr(xhr));
-                        rejectFunc && rejectFunc(event);
-                    };
-                    if (!sync && _enableSendPromise) {
-                        thePromise = createPromise(function (resolve, reject) {
-                            resolveFunc = resolve;
-                            rejectFunc = reject;
-                        });
                     }
-                    xhr.send(payload[_DYN_DATA ]);
-                    return thePromise;
+                    else {
+                        _fallbackSend && _fallbackSend(data, true);
+                        _throwInternal(_self[_DYN_DIAG_LOG ](), 2 , 40 , ". " + "Failed to send telemetry with Beacon API, retried with normal sender.");
+                    }
                 }
                 function _fetchKeepAliveSender(payload, isAsync) {
-                    var onComplete = function (status, headers, response) {
-                        return _getOnComplete(payload, status, headers, response);
-                    };
+                    var transport = null;
                     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);
-                        _self._buffer[_DYN_MARK_AS_SENT ](payload);
-                        if ((_syncFetchPayload + payloadSize) <= FetchSyncRequestSizeLimitBytes) {
-                            _doFetchSender(payloadData, onComplete, true);
+                        var syncFetchPayload = _sendPostMgr.getSyncFetchPayload();
+                        if ((syncFetchPayload + payloadSize) <= FetchSyncRequestSizeLimitBytes) {
+                            transport = 2 ;
                         }
                         else if (isBeaconsSupported()) {
-                            _beaconSender(payloadData);
+                            transport = 3 ;
                         }
                         else {
-                            _fallbackSend && _fallbackSend(payload, true);
+                            transport = 1 ;
                             _throwInternal(_self[_DYN_DIAG_LOG ](), 2 , 40 , ". " + "Failed to send telemetry with Beacon API, retried with xhrSender.");
                         }
-                    }
-                }
-                function _doFetchSender(payload, oncomplete, sync) {
-                    var _a;
-                    var endPointUrl = _endpointUrl;
-                    var internalPayload = payload;
-                    var batch = internalPayload[_DYN_DATA ];
-                    var plainTextBatch = new Blob([batch], { type: "application/json" });
-                    var thePromise;
-                    var resolveFunc;
-                    var rejectFunc;
-                    var requestHeaders = new Headers();
-                    var batchLength = batch[_DYN_LENGTH ];
-                    var ignoreResponse = false;
-                    var responseHandled = false;
-                    if (isInternalApplicationInsightsEndpoint(endPointUrl)) {
-                        requestHeaders.append(RequestHeaders[6 ], RequestHeaders[7 ]);
-                    }
-                    arrForEach(objKeys(_headers), function (headerName) {
-                        requestHeaders.append(headerName, _headers[headerName]);
-                    });
-                    var init = (_a = {
-                            method: "POST",
-                            headers: requestHeaders,
-                            body: plainTextBatch
-                        },
-                        _a[DisabledPropertyName] = true
-                    ,
-                        _a);
-                    if (sync) {
-                        init.keepalive = true;
-                        ignoreResponse = true;
-                        _syncFetchPayload += batchLength;
-                    }
-                    var request = new Request(endPointUrl, init);
-                    try {
-                        request[DisabledPropertyName] = true;
-                    }
-                    catch (e) {
-                    }
-                    if (!sync && _enableSendPromise) {
-                        thePromise = createPromise(function (resolve, reject) {
-                            resolveFunc = resolve;
-                            rejectFunc = reject;
-                        });
-                    }
-                    try {
-                        doAwaitResponse(fetch(request), function (result) {
-                            if (sync) {
-                                _syncFetchPayload -= batchLength;
-                                batchLength = 0;
-                            }
-                            if (!responseHandled) {
-                                responseHandled = true;
-                                if (!result.rejected) {
-                                    var response_1 = result.value;
-                                    if (!response_1.ok) {
-                                        _doOnComplete(oncomplete, 400, {}, response_1.statusText);
-                                        resolveFunc && resolveFunc(false);
-                                    }
-                                    else {
-                                        doAwaitResponse(response_1.text(), function (resp) {
-                                            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 {
-                                    _doOnComplete(oncomplete, 400, {}, result.reason && result.reason.message);
-                                    rejectFunc && rejectFunc(result.reason);
-                                }
-                            }
-                        });
-                    }
-                    catch (e) {
-                        if (!responseHandled) {
-                            _doOnComplete(oncomplete, 400, {}, dumpObj(e));
-                            rejectFunc && rejectFunc(e);
-                        }
-                    }
-                    if (ignoreResponse && !responseHandled) {
-                        responseHandled = true;
-                        _doOnComplete(oncomplete, 200, {});
-                        resolveFunc && resolveFunc(true);
-                    }
-                    return thePromise;
-                }
-                function _parseResponse(response) {
-                    try {
-                        if (response && response !== "") {
-                            var result = getJSON().parse(response);
-                            if (result && result.itemsReceived && result.itemsReceived >= result[_DYN_ITEMS_ACCEPTED ] &&
-                                result.itemsReceived - result.itemsAccepted === result.errors[_DYN_LENGTH ]) {
-                                return result;
-                            }
-                        }
-                    }
-                    catch (e) {
-                        _throwInternal(_self[_DYN_DIAG_LOG ](), 1 , 43 , "Cannot parse the response. " + getExceptionName(e), {
-                            response: response
-                        });
+                        var inst = _sendPostMgr && _sendPostMgr[_DYN_GET_XHR_INST ]([transport], true);
+                        return _doSend(inst, payload, isAsync);
                     }
                     return null;
                 }
@@ -6452,41 +6741,6 @@
                         || statusCode === 503
                         || statusCode === 504;
                 }
-                function _formatErrorMessageXhr(xhr, message) {
-                    if (xhr) {
-                        return "XMLHttpRequest,Status:" + xhr.status + ",Response:" + _getResponseText(xhr) || xhr.response || "";
-                    }
-                    return message;
-                }
-                function _xdrSender(payload, oncomplete, sync) {
-                    var internalPayload = payload;
-                    var _window = getWindow();
-                    var xdr = new XDomainRequest();
-                    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.");
-                        _self._buffer[_DYN_CLEAR ]();
-                        return;
-                    }
-                    var endpointUrl = _endpointUrl.replace(/^(https?:)/, "");
-                    xdr.open("POST", endpointUrl);
-                    xdr.send(data);
-                }
-                function _formatErrorMessageXdr(xdr, message) {
-                    if (xdr) {
-                        return "XDomainRequest,Response:" + _getResponseText(xdr) || "";
-                    }
-                    return message;
-                }
                 function _getNotifyMgr() {
                     var func = "getNotifyMgr";
                     if (_self.core[func]) {
@@ -6547,6 +6801,7 @@
                     _disableBeaconSplit = false;
                     _xhrSend = null;
                     _fallbackSend = null;
+                    _sendPostMgr = null;
                     objDefine(_self, "_senderConfig", {
                         g: function () {
                             return objExtend({}, defaultAppInsightsChannelConfig);