@microsoft/applicationinsights-web-basic 3.1.1-nightly3.2402-20 → 3.1.1-nightly3.2403-02

package/dist/es5/applicationinsights-web-basic.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript Web SDK - Basic, 3.1.1-nightly3.2402-20
+ * Application Insights JavaScript Web SDK - Basic, 3.1.1-nightly3.2403-02
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -1320,7 +1320,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";
@@ -1710,7 +1710,7 @@
     var createAllPromise = _createAllPromise(createPromise);
 
     var UNDEFINED_VALUE$1 = undefined;
-    var STR_EMPTY = "";
+    var STR_EMPTY$1 = "";
     var STR_CHANNELS = "channels";
     var STR_CORE = "core";
     var STR_CREATE_PERF_MGR = "createPerfMgr";
@@ -1723,6 +1723,9 @@
     var STR_EVENTS_DISCARDED = "eventsDiscarded";
     var STR_EVENTS_SEND_REQUEST = "eventsSendRequest";
     var STR_PERF_EVENT = "perfEvent";
+    var STR_OFFLINE_STORE = "offlineEventsStored";
+    var STR_OFFLINE_SENT = "offlineBatchSent";
+    var STR_OFFLINE_DROP = "offlineBatchDrop";
     var STR_GET_PERF_MGR = "getPerfMgr";
     var STR_DOMAIN = "domain";
     var STR_PATH = "path";
@@ -1760,7 +1763,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;
@@ -1963,7 +1966,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;
@@ -1972,9 +1975,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));
@@ -2083,7 +2086,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);
@@ -2121,11 +2124,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);
             },
@@ -2878,9 +2881,9 @@
         _a$4);
     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();
@@ -2902,12 +2905,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";
@@ -3146,7 +3149,7 @@
                     var result = false;
                     if (_isMgrEnabled(cookieMgr) && !_isBlockedCookie(cookieMgrConfig, name)) {
                         var values = {};
-                        var theValue = strTrim(value || STR_EMPTY);
+                        var theValue = strTrim(value || STR_EMPTY$1);
                         var idx = strIndexOf(theValue, ";");
                         if (idx !== -1) {
                             theValue = strTrim(strLeft(value, idx));
@@ -3161,11 +3164,11 @@
                                 if (expireMs > 0) {
                                     var expiry = new Date();
                                     expiry.setTime(expireMs);
-                                    setValue(values, strExpires, _formatDate(expiry, !_isIE ? strToUTCString : strToGMTString) || _formatDate(expiry, _isIE ? strToGMTString : strToUTCString) || STR_EMPTY, isTruthy);
+                                    setValue(values, strExpires, _formatDate(expiry, !_isIE ? strToUTCString : strToGMTString) || _formatDate(expiry, _isIE ? strToGMTString : strToUTCString) || STR_EMPTY$1, isTruthy);
                                 }
                             }
                             if (!_isIE) {
-                                setValue(values, "max-age", STR_EMPTY + maxAgeSec, null, isUndefined);
+                                setValue(values, "max-age", STR_EMPTY$1 + maxAgeSec, null, isUndefined);
                             }
                         }
                         var location_1 = getLocation();
@@ -3185,7 +3188,7 @@
                     return result;
                 },
                 get: function (name) {
-                    var value = STR_EMPTY;
+                    var value = STR_EMPTY$1;
                     if (_isMgrEnabled(cookieMgr) && !_isIgnoredCookie(cookieMgrConfig, name)) {
                         value = _getCookieFn(name);
                     }
@@ -3209,7 +3212,7 @@
                         if (!isIE()) {
                             values["max-age"] = "0";
                         }
-                        _delCookieFn(name, _formatCookieValue(STR_EMPTY, values));
+                        _delCookieFn(name, _formatCookieValue(STR_EMPTY$1, values));
                         result = true;
                     }
                     return result;
@@ -3242,7 +3245,7 @@
         if (theValue && theValue[_DYN_LENGTH$2 ]) {
             var parts = strTrim(theValue)[_DYN_SPLIT$1 ](";");
             arrForEach(parts, function (thePart) {
-                thePart = strTrim(thePart || STR_EMPTY);
+                thePart = strTrim(thePart || STR_EMPTY$1);
                 if (thePart) {
                     var idx = strIndexOf(thePart, "=");
                     if (idx === -1) {
@@ -3263,22 +3266,22 @@
         return null;
     }
     function _formatCookieValue(value, values) {
-        var cookieValue = value || STR_EMPTY;
+        var cookieValue = value || STR_EMPTY$1;
         objForEachKey(values, function (name, theValue) {
-            cookieValue += "; " + name + (!isNullOrUndefined(theValue) ? "=" + theValue : STR_EMPTY);
+            cookieValue += "; " + name + (!isNullOrUndefined(theValue) ? "=" + theValue : STR_EMPTY$1);
         });
         return cookieValue;
     }
     function _getCookieValue(name) {
-        var cookieValue = STR_EMPTY;
+        var cookieValue = STR_EMPTY$1;
         !_doc && _getDoc();
         if (_doc.v) {
-            var theCookie = _doc.v[strCookie] || STR_EMPTY;
+            var theCookie = _doc.v[strCookie] || STR_EMPTY$1;
             if (_parsedCookieValue !== theCookie) {
                 _cookieCache = _extractParts(theCookie);
                 _parsedCookieValue = theCookie;
             }
-            cookieValue = strTrim(_cookieCache[name] || STR_EMPTY);
+            cookieValue = strTrim(_cookieCache[name] || STR_EMPTY$1);
         }
         return cookieValue;
     }
@@ -3385,6 +3388,28 @@
                         }
                     }
                 };
+                _self[STR_OFFLINE_STORE ] = function (events) {
+                    if (events && events[_DYN_LENGTH$2 ]) {
+                        _runListeners(_listeners, STR_OFFLINE_STORE, true, function (listener) {
+                            listener[STR_OFFLINE_STORE ](events);
+                        });
+                    }
+                };
+                _self[STR_OFFLINE_SENT ] = function (batch) {
+                    if (batch && batch.data) {
+                        _runListeners(_listeners, STR_OFFLINE_SENT, true, function (listener) {
+                            listener[STR_OFFLINE_SENT ](batch);
+                        });
+                    }
+                };
+                _self[STR_OFFLINE_DROP ] = function (cnt, reason) {
+                    if (cnt > 0) {
+                        var rn_1 = reason || 0;
+                        _runListeners(_listeners, STR_OFFLINE_DROP, true, function (listener) {
+                            listener[STR_OFFLINE_DROP ](cnt, rn_1);
+                        });
+                    }
+                };
                 _self[_DYN_UNLOAD ] = function (isAsync) {
                     var _finishUnload = function () {
                         unloadHandler && unloadHandler.rm();
@@ -3608,7 +3633,7 @@
         }
         arrForEach(initPlugins, function (thePlugin) {
             var core = processContext[STR_CORE ]();
-            thePlugin[_DYN_INITIALIZE ](processContext.getCfg(), core, extensions, processContext[_DYN_GET_NEXT ]());
+            thePlugin[_DYN_INITIALIZE$1 ](processContext.getCfg(), core, extensions, processContext[_DYN_GET_NEXT ]());
             pluginState = _getPluginState(thePlugin);
             if (!thePlugin[STR_CORE] && !pluginState[STR_CORE]) {
                 pluginState[STR_CORE] = core;
@@ -3952,7 +3977,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;
                         }
@@ -4097,7 +4122,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;
                 };
@@ -4316,7 +4341,7 @@
         var channels = [];
         var extPriorities = {};
         arrForEach(allExtensions, function (ext) {
-            if (isNullOrUndefined(ext) || isNullOrUndefined(ext[_DYN_INITIALIZE ])) {
+            if (isNullOrUndefined(ext) || isNullOrUndefined(ext[_DYN_INITIALIZE$1 ])) {
                 throwError(strValidationError);
             }
             var extPriority = ext[STR_PRIORITY ];
@@ -4441,7 +4466,7 @@
                     return [_extensions];
                 };
                 _self[_DYN_IS_INITIALIZED ] = function () { return _isInitialized; };
-                _self[_DYN_INITIALIZE ] = function (config, extensions, logger, notificationManager) {
+                _self[_DYN_INITIALIZE$1 ] = function (config, extensions, logger, notificationManager) {
                     if (_isUnloading) {
                         throwError(strSdkUnloadingError);
                     }
@@ -4804,7 +4829,7 @@
                                 }
                                 _pluginVersionString = _pluginVersionStringArr.join(";");
                             }
-                            return _pluginVersionString || STR_EMPTY;
+                            return _pluginVersionString || STR_EMPTY$1;
                         }
                     });
                     objDefine(_self, "logger", {
@@ -5117,16 +5142,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) {
@@ -5144,13 +5169,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) {
@@ -5299,15 +5324,21 @@
     var _DYN_SPLIT = "split";
     var _DYN_LENGTH$1 = "length";
     var _DYN_TO_LOWER_CASE = "toLowerCase";
+    var _DYN_LOCATION = "location";
     var _DYN_INGESTIONENDPOINT = "ingestionendpoint";
     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";
@@ -5529,6 +5560,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 ,
@@ -5617,7 +5696,7 @@
         }, {});
         if (objKeys(result)[_DYN_LENGTH$1 ] > 0) {
             if (result.endpointsuffix) {
-                var locationPrefix = result.location ? result.location + "." : "";
+                var locationPrefix = result[_DYN_LOCATION ] ? result[_DYN_LOCATION ] + "." : "";
                 result[_DYN_INGESTIONENDPOINT ] = result[_DYN_INGESTIONENDPOINT ] || ("https://" + locationPrefix + "dc." + result.endpointsuffix);
             }
             result[_DYN_INGESTIONENDPOINT ] = result[_DYN_INGESTIONENDPOINT ] || DEFAULT_BREEZE_ENDPOINT;
@@ -5636,7 +5715,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 ,
@@ -5793,8 +5872,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);
@@ -6265,7 +6344,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);
@@ -6439,6 +6518,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);
     }
@@ -6577,43 +7010,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$1 = "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";
@@ -6727,7 +7159,7 @@
         }
     }
     var EnvelopeCreator = {
-        Version: '3.1.1-nightly3.2402-20'
+        Version: '3.1.1-nightly3.2403-02'
     };
     function DependencyEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
         EnvelopeCreatorInit(logger, telemetryItem);
@@ -6918,7 +7350,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") :
@@ -6968,7 +7400,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 ];
                 }
@@ -6995,7 +7427,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 ];
@@ -7228,7 +7660,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) {
@@ -7308,18 +7740,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)
@@ -7332,7 +7753,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$1 ] = UNDEFINED_VALUE,
@@ -7397,6 +7818,7 @@
             var _xhrSend;
             var _fallbackSend;
             var _disableBeaconSplit;
+            var _sendPostMgr;
             dynamicProto(Sender, _this, function (_self, _base) {
                 _initDefaults();
                 _self.pause = function () {
@@ -7441,11 +7863,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;
@@ -7480,7 +7902,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());
@@ -7522,13 +7944,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);
                         };
@@ -7542,11 +7972,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) {
@@ -7588,10 +8018,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; }
@@ -7667,7 +8095,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);
@@ -7680,22 +8108,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;
@@ -7791,36 +8286,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 ]);
@@ -7835,7 +8300,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);
@@ -7847,7 +8312,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,
@@ -7860,9 +8325,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) {
@@ -7876,7 +8338,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;
                         }
@@ -7908,7 +8370,7 @@
                         _checkAndUpdateEndPointUrl(responseUrl);
                         if (status === 206) {
                             if (!response) {
-                                response = _parseResponse(res);
+                                response = parseResponse(res);
                             }
                             if (response && !_isRetryDisabled) {
                                 _self[_DYN__ON_PARTIAL_SUCCESS ](payload, response);
@@ -7936,223 +8398,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);
-                    }
-                }
-                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 ]);
+                        var beaconInst = _sendPostMgr && _sendPostMgr[_DYN_GET_XHR_INST ]([3 ], true);
+                        return _doSend(beaconInst, payload, isAsync);
                     }
-                    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;
                 }
@@ -8211,41 +8511,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]) {
@@ -8306,6 +8571,7 @@
                     _disableBeaconSplit = false;
                     _xhrSend = null;
                     _fallbackSend = null;
+                    _sendPostMgr = null;
                     objDefine(_self, "_senderConfig", {
                         g: function () {
                             return objExtend({}, defaultAppInsightsChannelConfig);
@@ -8331,6 +8597,8 @@
 
     var _DYN_INSTRUMENTATION_KEY = "instrumentationKey";
     var _DYN_CONNECTION_STRING = "connectionString";
+    var _DYN_ENDPOINT_URL = "endpointUrl";
+    var _DYN_USER_OVERRIDE_ENDPOI0 = "userOverrideEndpointUrl";
 
     var defaultConfigValues = {
         diagnosticLogInterval: cfgDfValidate(_chkDiagLevel, 10000)
@@ -8371,9 +8639,10 @@
                         if (_config[_DYN_CONNECTION_STRING ]) {
                             var cs = parseConnectionString(_config[_DYN_CONNECTION_STRING ]);
                             var ingest = cs.ingestionendpoint;
-                            _config.endpointUrl = ingest ? (ingest + DEFAULT_BREEZE_PATH) : _config.endpointUrl;
+                            _config[_DYN_ENDPOINT_URL ] = _config[_DYN_USER_OVERRIDE_ENDPOI0 ] ? _config[_DYN_USER_OVERRIDE_ENDPOI0 ] : (ingest + DEFAULT_BREEZE_PATH);
                             _config[_DYN_INSTRUMENTATION_KEY ] = cs.instrumentationkey || _config[_DYN_INSTRUMENTATION_KEY ];
                         }
+                        _config[_DYN_ENDPOINT_URL ] = _config[_DYN_USER_OVERRIDE_ENDPOI0 ] ? _config[_DYN_USER_OVERRIDE_ENDPOI0 ] : _config[_DYN_ENDPOINT_URL ];
                     }));
                     core.initialize(_config, [new Sender()]);
                 }