@microsoft/applicationinsights-web 2.7.0-beta.1 → 2.7.1-nightly.202110-04

package/browser/{ai.2.7.0-beta.1.cjs.js → ai.2.7.1-nightly.202110-04.cjs.js}

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Web, 2.7.0-beta.1
+ * Application Insights JavaScript SDK - Web, 2.7.1-nightly.202110-04
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 'use strict';
@@ -436,8 +436,6 @@ var _InternalMessageId = {
 var strOnPrefix = "on";
 var strAttachEvent = "attachEvent";
 var strAddEventHelper = "addEventListener";
-var strDetachEvent = "detachEvent";
-var strRemoveEventListener = "removeEventListener";
 var _objDefineProperty = ObjDefineProperty;
 function objToString(obj) {
     return ObjProto.toString.call(obj);
@@ -482,21 +480,6 @@ function attachEvent(obj, eventNameWithoutOn, handlerRef, useCapture) {
     }
     return result;
 }
-function detachEvent(obj, eventNameWithoutOn, handlerRef, useCapture) {
-    if (useCapture === void 0) { useCapture = false; }
-    if (!isNullOrUndefined(obj)) {
-        try {
-            if (!isNullOrUndefined(obj[strRemoveEventListener])) {
-                obj[strRemoveEventListener](eventNameWithoutOn, handlerRef, useCapture);
-            }
-            else if (!isNullOrUndefined(obj[strDetachEvent])) {
-                obj[strDetachEvent](strOnPrefix + eventNameWithoutOn, handlerRef);
-            }
-        }
-        catch (e) {
-        }
-    }
-}
 function normalizeJsName(name) {
     var value = name;
     var match = /([^\w\d_$])/g;
@@ -579,33 +562,45 @@ function toISOString(date) {
 }
 function arrForEach(arr, callbackfn, thisArg) {
     var len = arr.length;
-    for (var idx = 0; idx < len; idx++) {
-        if (idx in arr) {
-            if (callbackfn.call(thisArg || arr, arr[idx], idx, arr) === -1) {
-                break;
+    try {
+        for (var idx = 0; idx < len; idx++) {
+            if (idx in arr) {
+                if (callbackfn.call(thisArg || arr, arr[idx], idx, arr) === -1) {
+                    break;
+                }
             }
         }
     }
+    catch (e) {
+    }
 }
 function arrIndexOf(arr, searchElement, fromIndex) {
     var len = arr.length;
     var from = fromIndex || 0;
-    for (var lp = Math.max(from >= 0 ? from : len - Math.abs(from), 0); lp < len; lp++) {
-        if (lp in arr && arr[lp] === searchElement) {
-            return lp;
+    try {
+        for (var lp = Math.max(from >= 0 ? from : len - Math.abs(from), 0); lp < len; lp++) {
+            if (lp in arr && arr[lp] === searchElement) {
+                return lp;
+            }
         }
     }
+    catch (e) {
+    }
     return -1;
 }
 function arrMap(arr, callbackfn, thisArg) {
     var len = arr.length;
     var _this = thisArg || arr;
     var results = new Array(len);
-    for (var lp = 0; lp < len; lp++) {
-        if (lp in arr) {
-            results[lp] = callbackfn.call(_this, arr[lp], arr);
+    try {
+        for (var lp = 0; lp < len; lp++) {
+            if (lp in arr) {
+                results[lp] = callbackfn.call(_this, arr[lp], arr);
+            }
         }
     }
+    catch (e) {
+    }
     return results;
 }
 function arrReduce(arr, callbackfn, initialValue) {
@@ -805,6 +800,33 @@ var strTrident = "trident/";
 var _isTrident = null;
 var _navUserAgentCheck = null;
 var _enableMocks = false;
+var _useXDomainRequest = null;
+var _beaconsSupported = null;
+function _hasProperty(theClass, property) {
+    var supported = false;
+    if (theClass) {
+        try {
+            supported = property in theClass;
+            if (!supported) {
+                var proto = theClass[strShimPrototype];
+                if (proto) {
+                    supported = property in proto;
+                }
+            }
+        }
+        catch (e) {
+        }
+        if (!supported) {
+            try {
+                var tmp = new theClass();
+                supported = !isUndefined(tmp[property]);
+            }
+            catch (e) {
+            }
+        }
+    }
+    return supported;
+}
 function getGlobalInst(name) {
     var gbl = getGlobal();
     if (gbl && gbl[name]) {
@@ -932,6 +954,45 @@ function dumpObj(object) {
     }
     return objectTypeDump + propertyValueDump;
 }
+function isBeaconsSupported() {
+    if (_beaconsSupported === null) {
+        _beaconsSupported = hasNavigator() && Boolean(getNavigator().sendBeacon);
+    }
+    return _beaconsSupported;
+}
+function isFetchSupported(withKeepAlive) {
+    var isSupported = false;
+    try {
+        var fetchApi = getGlobalInst("fetch");
+        isSupported = !!fetchApi;
+        var request = getGlobalInst("Request");
+        if (isSupported && withKeepAlive && request) {
+            isSupported = _hasProperty(request, "keepalive");
+        }
+    }
+    catch (e) {
+    }
+    return isSupported;
+}
+function useXDomainRequest() {
+    if (_useXDomainRequest === null) {
+        _useXDomainRequest = (typeof XDomainRequest !== undefined);
+        if (_useXDomainRequest && isXhrSupported()) {
+            _useXDomainRequest = _useXDomainRequest && !_hasProperty(getGlobalInst("XMLHttpRequest"), "withCredentials");
+        }
+    }
+    return _useXDomainRequest;
+}
+function isXhrSupported() {
+    var isSupported = false;
+    try {
+        var xmlHttpRequest = getGlobalInst("XMLHttpRequest");
+        isSupported = !!xmlHttpRequest;
+    }
+    catch (e) {
+    }
+    return isSupported;
+}
 
 var AiNonUserActionablePrefix = "AI (Internal): ";
 var AiUserActionablePrefix = "AI: ";
@@ -1238,7 +1299,7 @@ var TelemetryPluginChain = /** @class */ (function () {
                     catch (error) {
                         var hasRun = _nextProxy && _nextProxy._hasRun;
                         if (!_nextProxy || !hasRun) {
-                            itemCtx.diagLog().throwInternal(LoggingSeverity.CRITICAL, _InternalMessageId.PluginException, "Plugin [" + plugin.identifier + "] failed during processTelemetry - " + error);
+                            itemCtx.diagLog().throwInternal(LoggingSeverity.CRITICAL, _InternalMessageId.PluginException, "Plugin [" + plugin.identifier + "] failed during processTelemetry - " + dumpObj(error));
                         }
                         if (_nextProxy && !hasRun) {
                             _nextProxy.processTelemetry(env, itemCtx);
@@ -1857,7 +1918,7 @@ var BaseCore = /** @class */ (function () {
                     _self.logger = logger;
                 }
                 var allExtensions = [];
-                allExtensions.push.apply(allExtensions, __spreadArrayFn(__spreadArrayFn([], extensions), config.extensions));
+                allExtensions.push.apply(allExtensions, __spreadArrayFn(__spreadArrayFn([], extensions, false), config.extensions));
                 allExtensions = sortPlugins(allExtensions);
                 var coreExtensions = [];
                 var extPriorities = {};
@@ -2037,6 +2098,7 @@ var AppInsightsCore = /** @class */ (function (_super) {
     __extendsFn(AppInsightsCore, _super);
     function AppInsightsCore() {
         var _this = _super.call(this) || this;
+        var _internalLogPoller = 0;
         dynamicProto(AppInsightsCore, _this, function (_self, _base) {
             _self.initialize = function (config, extensions, logger, notificationManager) {
                 _base.initialize(config, extensions, logger || new DiagnosticLogger(config), notificationManager || new NotificationManager(config));
@@ -2068,7 +2130,10 @@ var AppInsightsCore = /** @class */ (function (_super) {
                 if (!interval || !(interval > 0)) {
                     interval = 10000;
                 }
-                return setInterval(function () {
+                if (_internalLogPoller) {
+                    _self.stopPollingInternalLogs();
+                }
+                _internalLogPoller = setInterval(function () {
                     var queue = _self.logger ? _self.logger.queue : [];
                     arrForEach(queue, function (logMessage) {
                         var item = {
@@ -2082,6 +2147,13 @@ var AppInsightsCore = /** @class */ (function (_super) {
                     });
                     queue.length = 0;
                 }, interval);
+                return _internalLogPoller;
+            };
+            _self.stopPollingInternalLogs = function () {
+                if (!_internalLogPoller)
+                    return;
+                clearInterval(_internalLogPoller);
+                _internalLogPoller = 0;
             };
             function _validateTelemetryItem(telemetryItem) {
                 if (isNullOrUndefined(telemetryItem.name)) {
@@ -2177,7 +2249,7 @@ function addEventHandler(eventName, callback) {
     }
     var doc = getDocument();
     if (doc) {
-        result = EventHelper.Attach(doc, eventName, callback) || result;
+        result = attachEvent(doc, eventName, callback) || result;
     }
     return result;
 }
@@ -2269,12 +2341,6 @@ var CoreUtils = {
     generateW3CId: generateW3CId
 };
 var GuidRegex = /[xy]/g;
-var EventHelper = {
-    Attach: attachEvent,
-    AttachEvent: attachEvent,
-    Detach: detachEvent,
-    DetachEvent: detachEvent
-};
 function _legacyCookieMgr(config, logger) {
     var cookieMgr = _gblCookieMgr(config, logger);
     var legacyCanUseCookies = CoreUtils._canUseCookies;
@@ -2657,10 +2723,6 @@ function msToTimeSpan(totalms) {
     hour = hour.length < 2 ? "0" + hour : hour;
     return (days > 0 ? days + "." : "") + hour + ":" + min + ":" + sec + "." + ms;
 }
-function isBeaconApiSupported() {
-    var nav = getNavigator();
-    return ('sendBeacon' in nav && nav.sendBeacon);
-}
 function getExtensionByName(extensions, identifier) {
     var extension = null;
     arrForEach(extensions, function (value) {
@@ -2681,6 +2743,7 @@ var ProcessLegacy = "ProcessLegacy";
 var HttpMethod = "http.method";
 var DEFAULT_BREEZE_ENDPOINT = "https://dc.services.visualstudio.com";
 var strNotSpecified = "not_specified";
+var strIkey = "iKey";
 
 var StorageType;
 (function (StorageType) {
@@ -2954,7 +3017,7 @@ var Util = {
     dump: dumpObj,
     getExceptionName: getExceptionName,
     addEventHandler: attachEvent,
-    IsBeaconApiSupported: isBeaconApiSupported,
+    IsBeaconApiSupported: isBeaconsSupported,
     getExtension: getExtensionByName
 };
 var UrlHelper = {
@@ -3252,14 +3315,22 @@ function _formatMessage(theEvent, errorType) {
     return evtMessage || "";
 }
 function _isExceptionDetailsInternal(value) {
-    if (isObject(value)) {
-        return "hasFullStack" in value && "typeName" in value;
+    try {
+        if (isObject(value)) {
+            return "hasFullStack" in value && "typeName" in value;
+        }
+    }
+    catch (e) {
     }
     return false;
 }
 function _isExceptionInternal(value) {
-    if (isObject(value)) {
-        return ("ver" in value && "exceptions" in value && "properties" in value);
+    try {
+        if (isObject(value)) {
+            return ("ver" in value && "exceptions" in value && "properties" in value);
+        }
+    }
+    catch (e) {
     }
     return false;
 }
@@ -4034,10 +4105,15 @@ var TelemetryItemCreator = /** @class */ (function () {
             isNullOrUndefined(envelopeName)) {
             throw Error("Input doesn't contain all required fields");
         }
+        var iKey = "";
+        if (item[strIkey]) {
+            iKey = item[strIkey];
+            delete item[strIkey];
+        }
         var telemetryItem = {
             name: envelopeName,
             time: toISOString(new Date()),
-            iKey: "",
+            iKey: iKey,
             ext: systemProperties ? systemProperties : {},
             tags: [],
             data: {},
@@ -4973,7 +5049,7 @@ var ApplicationInsights = /** @class */ (function (_super) {
         config.disableFlushOnUnload = stringToBoolOrDefault(config.disableFlushOnUnload, config.disableFlushOnBeforeUnload);
         return config;
     };
-    ApplicationInsights.Version = "2.7.0-beta.1";
+    ApplicationInsights.Version = "2.7.1-nightly.202110-04";
     return ApplicationInsights;
 }(BaseTelemetryPlugin));
 var Timing = /** @class */ (function () {
@@ -5003,18 +5079,35 @@ var Timing = /** @class */ (function () {
     return Timing;
 }());
 
-var ArraySendBuffer = /** @class */ (function () {
-    function ArraySendBuffer(config) {
+var BaseSendBuffer = /** @class */ (function () {
+    function BaseSendBuffer(config) {
         var _buffer = [];
-        dynamicProto(ArraySendBuffer, this, function (_self) {
+        this._get = function () {
+            return _buffer;
+        };
+        this._set = function (buffer) {
+            _buffer = buffer;
+            return _buffer;
+        };
+        dynamicProto(BaseSendBuffer, this, function (_self) {
             _self.enqueue = function (payload) {
                 _buffer.push(payload);
             };
             _self.count = function () {
                 return _buffer.length;
             };
+            _self.size = function () {
+                var size = _buffer.length;
+                for (var lp = 0; lp < _buffer.length; lp++) {
+                    size += _buffer[lp].length;
+                }
+                if (!config.emitLineDelimitedJson()) {
+                    size += 2;
+                }
+                return size;
+            };
             _self.clear = function () {
-                _buffer.length = 0;
+                _buffer = [];
             };
             _self.getItems = function () {
                 return _buffer.slice(0);
@@ -5028,63 +5121,58 @@ var ArraySendBuffer = /** @class */ (function () {
                 }
                 return null;
             };
+        });
+    }
+    return BaseSendBuffer;
+}());
+var ArraySendBuffer = /** @class */ (function (_super) {
+    __extendsFn(ArraySendBuffer, _super);
+    function ArraySendBuffer(config) {
+        var _this = _super.call(this, config) || this;
+        dynamicProto(ArraySendBuffer, _this, function (_self, _base) {
             _self.markAsSent = function (payload) {
-                _self.clear();
+                _base.clear();
             };
             _self.clearSent = function (payload) {
             };
         });
+        return _this;
     }
     return ArraySendBuffer;
-}());
-var SessionStorageSendBuffer = /** @class */ (function () {
+}(BaseSendBuffer));
+var SessionStorageSendBuffer = /** @class */ (function (_super) {
+    __extendsFn(SessionStorageSendBuffer, _super);
     function SessionStorageSendBuffer(logger, config) {
+        var _this = _super.call(this, config) || this;
         var _bufferFullMessageSent = false;
-        var _buffer;
-        dynamicProto(SessionStorageSendBuffer, this, function (_self) {
+        dynamicProto(SessionStorageSendBuffer, _this, function (_self, _base) {
             var bufferItems = _getBuffer(SessionStorageSendBuffer.BUFFER_KEY);
             var notDeliveredItems = _getBuffer(SessionStorageSendBuffer.SENT_BUFFER_KEY);
-            _buffer = bufferItems.concat(notDeliveredItems);
-            if (_buffer.length > SessionStorageSendBuffer.MAX_BUFFER_SIZE) {
-                _buffer.length = SessionStorageSendBuffer.MAX_BUFFER_SIZE;
+            var buffer = _self._set(bufferItems.concat(notDeliveredItems));
+            if (buffer.length > SessionStorageSendBuffer.MAX_BUFFER_SIZE) {
+                buffer.length = SessionStorageSendBuffer.MAX_BUFFER_SIZE;
             }
             _setBuffer(SessionStorageSendBuffer.SENT_BUFFER_KEY, []);
-            _setBuffer(SessionStorageSendBuffer.BUFFER_KEY, _buffer);
+            _setBuffer(SessionStorageSendBuffer.BUFFER_KEY, buffer);
             _self.enqueue = function (payload) {
-                if (_buffer.length >= SessionStorageSendBuffer.MAX_BUFFER_SIZE) {
+                if (_self.count() >= SessionStorageSendBuffer.MAX_BUFFER_SIZE) {
                     if (!_bufferFullMessageSent) {
-                        logger.throwInternal(LoggingSeverity.WARNING, _InternalMessageId.SessionStorageBufferFull, "Maximum buffer size reached: " + _buffer.length, true);
+                        logger.throwInternal(LoggingSeverity.WARNING, _InternalMessageId.SessionStorageBufferFull, "Maximum buffer size reached: " + _self.count(), true);
                         _bufferFullMessageSent = true;
                     }
                     return;
                 }
-                _buffer.push(payload);
-                _setBuffer(SessionStorageSendBuffer.BUFFER_KEY, _buffer);
-            };
-            _self.count = function () {
-                return _buffer.length;
+                _base.enqueue(payload);
+                _setBuffer(SessionStorageSendBuffer.BUFFER_KEY, _self._get());
             };
             _self.clear = function () {
-                _buffer = [];
-                _setBuffer(SessionStorageSendBuffer.BUFFER_KEY, []);
+                _base.clear();
+                _setBuffer(SessionStorageSendBuffer.BUFFER_KEY, _self._get());
                 _setBuffer(SessionStorageSendBuffer.SENT_BUFFER_KEY, []);
                 _bufferFullMessageSent = false;
             };
-            _self.getItems = function () {
-                return _buffer.slice(0);
-            };
-            _self.batchPayloads = function (payload) {
-                if (payload && payload.length > 0) {
-                    var batch = config.emitLineDelimitedJson() ?
-                        payload.join("\n") :
-                        "[" + payload.join(",") + "]";
-                    return batch;
-                }
-                return null;
-            };
             _self.markAsSent = function (payload) {
-                _buffer = _removePayloadsFromBuffer(payload, _buffer);
-                _setBuffer(SessionStorageSendBuffer.BUFFER_KEY, _buffer);
+                _setBuffer(SessionStorageSendBuffer.BUFFER_KEY, _self._set(_removePayloadsFromBuffer(payload, _self._get())));
                 var sentElements = _getBuffer(SessionStorageSendBuffer.SENT_BUFFER_KEY);
                 if (sentElements instanceof Array && payload instanceof Array) {
                     sentElements = sentElements.concat(payload);
@@ -5115,12 +5203,12 @@ var SessionStorageSendBuffer = /** @class */ (function () {
                     prefixedKey = config.namePrefix && config.namePrefix() ? config.namePrefix() + "_" + prefixedKey : prefixedKey;
                     var bufferJson = utlGetSessionStorage(logger, prefixedKey);
                     if (bufferJson) {
-                        var buffer = getJSON().parse(bufferJson);
-                        if (isString(buffer)) {
-                            buffer = getJSON().parse(buffer);
+                        var buffer_1 = getJSON().parse(bufferJson);
+                        if (isString(buffer_1)) {
+                            buffer_1 = getJSON().parse(buffer_1);
                         }
-                        if (buffer && isArray(buffer)) {
-                            return buffer;
+                        if (buffer_1 && isArray(buffer_1)) {
+                            return buffer_1;
                         }
                     }
                 }
@@ -5142,12 +5230,13 @@ var SessionStorageSendBuffer = /** @class */ (function () {
                 }
             }
         });
+        return _this;
     }
     SessionStorageSendBuffer.BUFFER_KEY = "AI_buffer";
     SessionStorageSendBuffer.SENT_BUFFER_KEY = "AI_sentBuffer";
     SessionStorageSendBuffer.MAX_BUFFER_SIZE = 2000;
     return SessionStorageSendBuffer;
-}());
+}(BaseSendBuffer));
 
 var strBaseType = 'baseType';
 var strBaseData = 'baseData';
@@ -5156,317 +5245,257 @@ var strTrue = 'true';
 function _setValueIf(target, field, value) {
     return setValue(target, field, value, isTruthy);
 }
-var EnvelopeCreator = /** @class */ (function () {
-    function EnvelopeCreator() {
-    }
-    EnvelopeCreator.extractPropsAndMeasurements = function (data, properties, measurements) {
-        if (!isNullOrUndefined(data)) {
-            objForEachKey(data, function (key, value) {
-                if (isNumber(value)) {
-                    measurements[key] = value;
-                }
-                else if (isString(value)) {
-                    properties[key] = value;
-                }
-                else if (hasJSON()) {
-                    properties[key] = getJSON().stringify(value);
-                }
-            });
-        }
-    };
-    EnvelopeCreator.convertPropsUndefinedToCustomDefinedValue = function (properties, customUndefinedValue) {
-        if (!isNullOrUndefined(properties)) {
-            objForEachKey(properties, function (key, value) {
-                properties[key] = value || customUndefinedValue;
-            });
-        }
-    };
-    EnvelopeCreator.createEnvelope = function (logger, envelopeType, telemetryItem, data) {
-        var envelope = new Envelope(logger, data, envelopeType);
-        _setValueIf(envelope, 'sampleRate', telemetryItem[SampleRate]);
-        if ((telemetryItem[strBaseData] || {}).startTime) {
-            envelope.time = toISOString(telemetryItem[strBaseData].startTime);
-        }
-        envelope.iKey = telemetryItem.iKey;
-        var iKeyNoDashes = telemetryItem.iKey.replace(/-/g, "");
-        envelope.name = envelope.name.replace("{0}", iKeyNoDashes);
-        EnvelopeCreator.extractPartAExtensions(telemetryItem, envelope);
-        telemetryItem.tags = telemetryItem.tags || [];
-        return optimizeObject(envelope);
-    };
-    EnvelopeCreator.extractPartAExtensions = function (item, env) {
-        var envTags = env.tags = env.tags || {};
-        var itmExt = item.ext = item.ext || {};
-        var itmTags = item.tags = item.tags || [];
-        var extUser = itmExt.user;
-        if (extUser) {
-            _setValueIf(envTags, CtxTagKeys.userAuthUserId, extUser.authId);
-            _setValueIf(envTags, CtxTagKeys.userId, extUser.id || extUser.localId);
-        }
-        var extApp = itmExt.app;
-        if (extApp) {
-            _setValueIf(envTags, CtxTagKeys.sessionId, extApp.sesId);
-        }
-        var extDevice = itmExt.device;
-        if (extDevice) {
-            _setValueIf(envTags, CtxTagKeys.deviceId, extDevice.id || extDevice.localId);
-            _setValueIf(envTags, CtxTagKeys.deviceType, extDevice.deviceClass);
-            _setValueIf(envTags, CtxTagKeys.deviceIp, extDevice.ip);
-            _setValueIf(envTags, CtxTagKeys.deviceModel, extDevice.model);
-            _setValueIf(envTags, CtxTagKeys.deviceType, extDevice.deviceType);
-        }
-        var web = item.ext.web;
-        if (web) {
-            _setValueIf(envTags, CtxTagKeys.deviceLanguage, web.browserLang);
-            _setValueIf(envTags, CtxTagKeys.deviceBrowserVersion, web.browserVer);
-            _setValueIf(envTags, CtxTagKeys.deviceBrowser, web.browser);
-            var envData = env.data = env.data || {};
-            var envBaseData = envData[strBaseData] = envData[strBaseData] || {};
-            var envProps = envBaseData[strProperties$1] = envBaseData[strProperties$1] || {};
-            _setValueIf(envProps, 'domain', web.domain);
-            _setValueIf(envProps, 'isManual', web.isManual ? strTrue : null);
-            _setValueIf(envProps, 'screenRes', web.screenRes);
-            _setValueIf(envProps, 'userConsent', web.userConsent ? strTrue : null);
-        }
-        var extOs = itmExt.os;
-        if (extOs) {
-            _setValueIf(envTags, CtxTagKeys.deviceOS, extOs.name);
-        }
-        var extTrace = itmExt.trace;
-        if (extTrace) {
-            _setValueIf(envTags, CtxTagKeys.operationParentId, extTrace.parentID);
-            _setValueIf(envTags, CtxTagKeys.operationName, extTrace.name);
-            _setValueIf(envTags, CtxTagKeys.operationId, extTrace.traceID);
-        }
-        var tgs = {};
-        for (var i = itmTags.length - 1; i >= 0; i--) {
-            var tg = itmTags[i];
-            objForEachKey(tg, function (key, value) {
-                tgs[key] = value;
-            });
-            itmTags.splice(i, 1);
-        }
-        objForEachKey(itmTags, function (tg, value) {
-            tgs[tg] = value;
+function _extractPartAExtensions(item, env) {
+    var envTags = env.tags = env.tags || {};
+    var itmExt = item.ext = item.ext || {};
+    var itmTags = item.tags = item.tags || [];
+    var extUser = itmExt.user;
+    if (extUser) {
+        _setValueIf(envTags, CtxTagKeys.userAuthUserId, extUser.authId);
+        _setValueIf(envTags, CtxTagKeys.userId, extUser.id || extUser.localId);
+    }
+    var extApp = itmExt.app;
+    if (extApp) {
+        _setValueIf(envTags, CtxTagKeys.sessionId, extApp.sesId);
+    }
+    var extDevice = itmExt.device;
+    if (extDevice) {
+        _setValueIf(envTags, CtxTagKeys.deviceId, extDevice.id || extDevice.localId);
+        _setValueIf(envTags, CtxTagKeys.deviceType, extDevice.deviceClass);
+        _setValueIf(envTags, CtxTagKeys.deviceIp, extDevice.ip);
+        _setValueIf(envTags, CtxTagKeys.deviceModel, extDevice.model);
+        _setValueIf(envTags, CtxTagKeys.deviceType, extDevice.deviceType);
+    }
+    var web = item.ext.web;
+    if (web) {
+        _setValueIf(envTags, CtxTagKeys.deviceLanguage, web.browserLang);
+        _setValueIf(envTags, CtxTagKeys.deviceBrowserVersion, web.browserVer);
+        _setValueIf(envTags, CtxTagKeys.deviceBrowser, web.browser);
+        var envData = env.data = env.data || {};
+        var envBaseData = envData[strBaseData] = envData[strBaseData] || {};
+        var envProps = envBaseData[strProperties$1] = envBaseData[strProperties$1] || {};
+        _setValueIf(envProps, 'domain', web.domain);
+        _setValueIf(envProps, 'isManual', web.isManual ? strTrue : null);
+        _setValueIf(envProps, 'screenRes', web.screenRes);
+        _setValueIf(envProps, 'userConsent', web.userConsent ? strTrue : null);
+    }
+    var extOs = itmExt.os;
+    if (extOs) {
+        _setValueIf(envTags, CtxTagKeys.deviceOS, extOs.name);
+    }
+    var extTrace = itmExt.trace;
+    if (extTrace) {
+        _setValueIf(envTags, CtxTagKeys.operationParentId, extTrace.parentID);
+        _setValueIf(envTags, CtxTagKeys.operationName, extTrace.name);
+        _setValueIf(envTags, CtxTagKeys.operationId, extTrace.traceID);
+    }
+    var tgs = {};
+    for (var i = itmTags.length - 1; i >= 0; i--) {
+        var tg = itmTags[i];
+        objForEachKey(tg, function (key, value) {
+            tgs[key] = value;
         });
-        var theTags = __assignFn(__assignFn({}, envTags), tgs);
-        if (!theTags[CtxTagKeys.internalSdkVersion]) {
-            theTags[CtxTagKeys.internalSdkVersion] = "javascript:" + EnvelopeCreator.Version;
-        }
-        env.tags = optimizeObject(theTags);
-    };
-    EnvelopeCreator.prototype.Init = function (logger, telemetryItem) {
-        this._logger = logger;
-        if (isNullOrUndefined(telemetryItem[strBaseData])) {
-            this._logger.throwInternal(LoggingSeverity.CRITICAL, _InternalMessageId.TelemetryEnvelopeInvalid, "telemetryItem.baseData cannot be null.");
-        }
-    };
-    EnvelopeCreator.Version = "2.7.0-beta.1";
-    return EnvelopeCreator;
-}());
-var DependencyEnvelopeCreator = /** @class */ (function (_super) {
-    __extendsFn(DependencyEnvelopeCreator, _super);
-    function DependencyEnvelopeCreator() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    DependencyEnvelopeCreator.prototype.Create = function (logger, telemetryItem, customUndefinedValue) {
-        _super.prototype.Init.call(this, logger, telemetryItem);
-        var customMeasurements = telemetryItem[strBaseData].measurements || {};
-        var customProperties = telemetryItem[strBaseData][strProperties$1] || {};
-        EnvelopeCreator.extractPropsAndMeasurements(telemetryItem.data, customProperties, customMeasurements);
-        if (!isNullOrUndefined(customUndefinedValue)) {
-            EnvelopeCreator.convertPropsUndefinedToCustomDefinedValue(customProperties, customUndefinedValue);
-        }
-        var bd = telemetryItem[strBaseData];
-        if (isNullOrUndefined(bd)) {
-            logger.warnToConsole("Invalid input for dependency data");
-            return null;
-        }
-        var method = bd[strProperties$1] && bd[strProperties$1][HttpMethod] ? bd[strProperties$1][HttpMethod] : "GET";
-        var remoteDepData = new RemoteDependencyData(logger, bd.id, bd.target, bd.name, bd.duration, bd.success, bd.responseCode, method, bd.type, bd.correlationContext, customProperties, customMeasurements);
-        var data = new Data(RemoteDependencyData.dataType, remoteDepData);
-        return EnvelopeCreator.createEnvelope(logger, RemoteDependencyData.envelopeType, telemetryItem, data);
-    };
-    DependencyEnvelopeCreator.DependencyEnvelopeCreator = new DependencyEnvelopeCreator();
-    return DependencyEnvelopeCreator;
-}(EnvelopeCreator));
-var EventEnvelopeCreator = /** @class */ (function (_super) {
-    __extendsFn(EventEnvelopeCreator, _super);
-    function EventEnvelopeCreator() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    EventEnvelopeCreator.prototype.Create = function (logger, telemetryItem, customUndefinedValue) {
-        _super.prototype.Init.call(this, logger, telemetryItem);
-        var customProperties = {};
-        var customMeasurements = {};
-        if (telemetryItem[strBaseType] !== Event$1.dataType) {
-            customProperties['baseTypeSource'] = telemetryItem[strBaseType];
-        }
-        if (telemetryItem[strBaseType] === Event$1.dataType) {
-            customProperties = telemetryItem[strBaseData][strProperties$1] || {};
-            customMeasurements = telemetryItem[strBaseData].measurements || {};
-        }
-        else {
-            if (telemetryItem[strBaseData]) {
-                EnvelopeCreator.extractPropsAndMeasurements(telemetryItem[strBaseData], customProperties, customMeasurements);
+        itmTags.splice(i, 1);
+    }
+    objForEachKey(itmTags, function (tg, value) {
+        tgs[tg] = value;
+    });
+    var theTags = __assignFn(__assignFn({}, envTags), tgs);
+    if (!theTags[CtxTagKeys.internalSdkVersion]) {
+        theTags[CtxTagKeys.internalSdkVersion] = "javascript:" + EnvelopeCreator.Version;
+    }
+    env.tags = optimizeObject(theTags);
+}
+function _extractPropsAndMeasurements(data, properties, measurements) {
+    if (!isNullOrUndefined(data)) {
+        objForEachKey(data, function (key, value) {
+            if (isNumber(value)) {
+                measurements[key] = value;
             }
-        }
-        EnvelopeCreator.extractPropsAndMeasurements(telemetryItem.data, customProperties, customMeasurements);
-        if (!isNullOrUndefined(customUndefinedValue)) {
-            EnvelopeCreator.convertPropsUndefinedToCustomDefinedValue(customProperties, customUndefinedValue);
-        }
-        var eventName = telemetryItem[strBaseData].name;
-        var eventData = new Event$1(logger, eventName, customProperties, customMeasurements);
-        var data = new Data(Event$1.dataType, eventData);
-        return EnvelopeCreator.createEnvelope(logger, Event$1.envelopeType, telemetryItem, data);
-    };
-    EventEnvelopeCreator.EventEnvelopeCreator = new EventEnvelopeCreator();
-    return EventEnvelopeCreator;
-}(EnvelopeCreator));
-var ExceptionEnvelopeCreator = /** @class */ (function (_super) {
-    __extendsFn(ExceptionEnvelopeCreator, _super);
-    function ExceptionEnvelopeCreator() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ExceptionEnvelopeCreator.prototype.Create = function (logger, telemetryItem, customUndefinedValue) {
-        _super.prototype.Init.call(this, logger, telemetryItem);
-        var customMeasurements = telemetryItem[strBaseData].measurements || {};
-        var customProperties = telemetryItem[strBaseData][strProperties$1] || {};
-        EnvelopeCreator.extractPropsAndMeasurements(telemetryItem.data, customProperties, customMeasurements);
-        if (!isNullOrUndefined(customUndefinedValue)) {
-            EnvelopeCreator.convertPropsUndefinedToCustomDefinedValue(customProperties, customUndefinedValue);
-        }
-        var bd = telemetryItem[strBaseData];
-        var exData = Exception.CreateFromInterface(logger, bd, customProperties, customMeasurements);
-        var data = new Data(Exception.dataType, exData);
-        return EnvelopeCreator.createEnvelope(logger, Exception.envelopeType, telemetryItem, data);
-    };
-    ExceptionEnvelopeCreator.ExceptionEnvelopeCreator = new ExceptionEnvelopeCreator();
-    return ExceptionEnvelopeCreator;
-}(EnvelopeCreator));
-var MetricEnvelopeCreator = /** @class */ (function (_super) {
-    __extendsFn(MetricEnvelopeCreator, _super);
-    function MetricEnvelopeCreator() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    MetricEnvelopeCreator.prototype.Create = function (logger, telemetryItem, customUndefinedValue) {
-        _super.prototype.Init.call(this, logger, telemetryItem);
-        var baseData = telemetryItem[strBaseData];
-        var props = baseData[strProperties$1] || {};
-        var measurements = baseData.measurements || {};
-        EnvelopeCreator.extractPropsAndMeasurements(telemetryItem.data, props, measurements);
-        if (!isNullOrUndefined(customUndefinedValue)) {
-            EnvelopeCreator.convertPropsUndefinedToCustomDefinedValue(props, customUndefinedValue);
-        }
-        var baseMetricData = new Metric(logger, baseData.name, baseData.average, baseData.sampleCount, baseData.min, baseData.max, props, measurements);
-        var data = new Data(Metric.dataType, baseMetricData);
-        return EnvelopeCreator.createEnvelope(logger, Metric.envelopeType, telemetryItem, data);
-    };
-    MetricEnvelopeCreator.MetricEnvelopeCreator = new MetricEnvelopeCreator();
-    return MetricEnvelopeCreator;
-}(EnvelopeCreator));
-var PageViewEnvelopeCreator = /** @class */ (function (_super) {
-    __extendsFn(PageViewEnvelopeCreator, _super);
-    function PageViewEnvelopeCreator() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    PageViewEnvelopeCreator.prototype.Create = function (logger, telemetryItem, customUndefinedValue) {
-        _super.prototype.Init.call(this, logger, telemetryItem);
-        var strDuration = "duration";
-        var duration;
-        var baseData = telemetryItem[strBaseData];
-        if (!isNullOrUndefined(baseData) &&
-            !isNullOrUndefined(baseData[strProperties$1]) &&
-            !isNullOrUndefined(baseData[strProperties$1][strDuration])) {
-            duration = baseData[strProperties$1][strDuration];
-            delete baseData[strProperties$1][strDuration];
-        }
-        else if (!isNullOrUndefined(telemetryItem.data) &&
-            !isNullOrUndefined(telemetryItem.data[strDuration])) {
-            duration = telemetryItem.data[strDuration];
-            delete telemetryItem.data[strDuration];
-        }
-        var bd = telemetryItem[strBaseData];
-        var currentContextId;
-        if (((telemetryItem.ext || {}).trace || {}).traceID) {
-            currentContextId = telemetryItem.ext.trace.traceID;
-        }
-        var id = bd.id || currentContextId;
-        var name = bd.name;
-        var url = bd.uri;
-        var properties = bd[strProperties$1] || {};
-        var measurements = bd.measurements || {};
-        if (!isNullOrUndefined(bd.refUri)) {
-            properties["refUri"] = bd.refUri;
-        }
-        if (!isNullOrUndefined(bd.pageType)) {
-            properties["pageType"] = bd.pageType;
-        }
-        if (!isNullOrUndefined(bd.isLoggedIn)) {
-            properties["isLoggedIn"] = bd.isLoggedIn.toString();
-        }
-        if (!isNullOrUndefined(bd[strProperties$1])) {
-            var pageTags = bd[strProperties$1];
-            objForEachKey(pageTags, function (key, value) {
+            else if (isString(value)) {
                 properties[key] = value;
-            });
-        }
-        EnvelopeCreator.extractPropsAndMeasurements(telemetryItem.data, properties, measurements);
-        if (!isNullOrUndefined(customUndefinedValue)) {
-            EnvelopeCreator.convertPropsUndefinedToCustomDefinedValue(properties, customUndefinedValue);
-        }
-        var pageViewData = new PageView(logger, name, url, duration, properties, measurements, id);
-        var data = new Data(PageView.dataType, pageViewData);
-        return EnvelopeCreator.createEnvelope(logger, PageView.envelopeType, telemetryItem, data);
-    };
-    PageViewEnvelopeCreator.PageViewEnvelopeCreator = new PageViewEnvelopeCreator();
-    return PageViewEnvelopeCreator;
-}(EnvelopeCreator));
-var PageViewPerformanceEnvelopeCreator = /** @class */ (function (_super) {
-    __extendsFn(PageViewPerformanceEnvelopeCreator, _super);
-    function PageViewPerformanceEnvelopeCreator() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    PageViewPerformanceEnvelopeCreator.prototype.Create = function (logger, telemetryItem, customUndefinedValue) {
-        _super.prototype.Init.call(this, logger, telemetryItem);
-        var bd = telemetryItem[strBaseData];
-        var name = bd.name;
-        var url = bd.uri || bd.url;
-        var properties = bd[strProperties$1] || {};
-        var measurements = bd.measurements || {};
-        EnvelopeCreator.extractPropsAndMeasurements(telemetryItem.data, properties, measurements);
-        if (!isNullOrUndefined(customUndefinedValue)) {
-            EnvelopeCreator.convertPropsUndefinedToCustomDefinedValue(properties, customUndefinedValue);
-        }
-        var baseData = new PageViewPerformance(logger, name, url, undefined, properties, measurements, bd);
-        var data = new Data(PageViewPerformance.dataType, baseData);
-        return EnvelopeCreator.createEnvelope(logger, PageViewPerformance.envelopeType, telemetryItem, data);
-    };
-    PageViewPerformanceEnvelopeCreator.PageViewPerformanceEnvelopeCreator = new PageViewPerformanceEnvelopeCreator();
-    return PageViewPerformanceEnvelopeCreator;
-}(EnvelopeCreator));
-var TraceEnvelopeCreator = /** @class */ (function (_super) {
-    __extendsFn(TraceEnvelopeCreator, _super);
-    function TraceEnvelopeCreator() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    TraceEnvelopeCreator.prototype.Create = function (logger, telemetryItem, customUndefinedValue) {
-        _super.prototype.Init.call(this, logger, telemetryItem);
-        var message = telemetryItem[strBaseData].message;
-        var severityLevel = telemetryItem[strBaseData].severityLevel;
-        var props = telemetryItem[strBaseData][strProperties$1] || {};
-        var measurements = telemetryItem[strBaseData].measurements || {};
-        EnvelopeCreator.extractPropsAndMeasurements(telemetryItem.data, props, measurements);
-        if (!isNullOrUndefined(customUndefinedValue)) {
-            EnvelopeCreator.convertPropsUndefinedToCustomDefinedValue(props, customUndefinedValue);
-        }
-        var baseData = new Trace(logger, message, severityLevel, props, measurements);
-        var data = new Data(Trace.dataType, baseData);
-        return EnvelopeCreator.createEnvelope(logger, Trace.envelopeType, telemetryItem, data);
-    };
-    TraceEnvelopeCreator.TraceEnvelopeCreator = new TraceEnvelopeCreator();
-    return TraceEnvelopeCreator;
-}(EnvelopeCreator));
+            }
+            else if (hasJSON()) {
+                properties[key] = getJSON().stringify(value);
+            }
+        });
+    }
+}
+function _convertPropsUndefinedToCustomDefinedValue(properties, customUndefinedValue) {
+    if (!isNullOrUndefined(properties)) {
+        objForEachKey(properties, function (key, value) {
+            properties[key] = value || customUndefinedValue;
+        });
+    }
+}
+function _createEnvelope(logger, envelopeType, telemetryItem, data) {
+    var envelope = new Envelope(logger, data, envelopeType);
+    _setValueIf(envelope, 'sampleRate', telemetryItem[SampleRate]);
+    if ((telemetryItem[strBaseData] || {}).startTime) {
+        envelope.time = toISOString(telemetryItem[strBaseData].startTime);
+    }
+    envelope.iKey = telemetryItem.iKey;
+    var iKeyNoDashes = telemetryItem.iKey.replace(/-/g, "");
+    envelope.name = envelope.name.replace("{0}", iKeyNoDashes);
+    _extractPartAExtensions(telemetryItem, envelope);
+    telemetryItem.tags = telemetryItem.tags || [];
+    return optimizeObject(envelope);
+}
+function EnvelopeCreatorInit(logger, telemetryItem) {
+    if (isNullOrUndefined(telemetryItem[strBaseData])) {
+        logger.throwInternal(LoggingSeverity.CRITICAL, _InternalMessageId.TelemetryEnvelopeInvalid, "telemetryItem.baseData cannot be null.");
+    }
+}
+var EnvelopeCreator = {
+    Version: "2.7.1-nightly.202110-04"
+};
+function DependencyEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
+    EnvelopeCreatorInit(logger, telemetryItem);
+    var customMeasurements = telemetryItem[strBaseData].measurements || {};
+    var customProperties = telemetryItem[strBaseData][strProperties$1] || {};
+    _extractPropsAndMeasurements(telemetryItem.data, customProperties, customMeasurements);
+    if (!isNullOrUndefined(customUndefinedValue)) {
+        _convertPropsUndefinedToCustomDefinedValue(customProperties, customUndefinedValue);
+    }
+    var bd = telemetryItem[strBaseData];
+    if (isNullOrUndefined(bd)) {
+        logger.warnToConsole("Invalid input for dependency data");
+        return null;
+    }
+    var method = bd[strProperties$1] && bd[strProperties$1][HttpMethod] ? bd[strProperties$1][HttpMethod] : "GET";
+    var remoteDepData = new RemoteDependencyData(logger, bd.id, bd.target, bd.name, bd.duration, bd.success, bd.responseCode, method, bd.type, bd.correlationContext, customProperties, customMeasurements);
+    var data = new Data(RemoteDependencyData.dataType, remoteDepData);
+    return _createEnvelope(logger, RemoteDependencyData.envelopeType, telemetryItem, data);
+}
+function EventEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
+    EnvelopeCreatorInit(logger, telemetryItem);
+    var customProperties = {};
+    var customMeasurements = {};
+    if (telemetryItem[strBaseType] !== Event$1.dataType) {
+        customProperties['baseTypeSource'] = telemetryItem[strBaseType];
+    }
+    if (telemetryItem[strBaseType] === Event$1.dataType) {
+        customProperties = telemetryItem[strBaseData][strProperties$1] || {};
+        customMeasurements = telemetryItem[strBaseData].measurements || {};
+    }
+    else {
+        if (telemetryItem[strBaseData]) {
+            _extractPropsAndMeasurements(telemetryItem[strBaseData], customProperties, customMeasurements);
+        }
+    }
+    _extractPropsAndMeasurements(telemetryItem.data, customProperties, customMeasurements);
+    if (!isNullOrUndefined(customUndefinedValue)) {
+        _convertPropsUndefinedToCustomDefinedValue(customProperties, customUndefinedValue);
+    }
+    var eventName = telemetryItem[strBaseData].name;
+    var eventData = new Event$1(logger, eventName, customProperties, customMeasurements);
+    var data = new Data(Event$1.dataType, eventData);
+    return _createEnvelope(logger, Event$1.envelopeType, telemetryItem, data);
+}
+function ExceptionEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
+    EnvelopeCreatorInit(logger, telemetryItem);
+    var customMeasurements = telemetryItem[strBaseData].measurements || {};
+    var customProperties = telemetryItem[strBaseData][strProperties$1] || {};
+    _extractPropsAndMeasurements(telemetryItem.data, customProperties, customMeasurements);
+    if (!isNullOrUndefined(customUndefinedValue)) {
+        _convertPropsUndefinedToCustomDefinedValue(customProperties, customUndefinedValue);
+    }
+    var bd = telemetryItem[strBaseData];
+    var exData = Exception.CreateFromInterface(logger, bd, customProperties, customMeasurements);
+    var data = new Data(Exception.dataType, exData);
+    return _createEnvelope(logger, Exception.envelopeType, telemetryItem, data);
+}
+function MetricEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
+    EnvelopeCreatorInit(logger, telemetryItem);
+    var baseData = telemetryItem[strBaseData];
+    var props = baseData[strProperties$1] || {};
+    var measurements = baseData.measurements || {};
+    _extractPropsAndMeasurements(telemetryItem.data, props, measurements);
+    if (!isNullOrUndefined(customUndefinedValue)) {
+        _convertPropsUndefinedToCustomDefinedValue(props, customUndefinedValue);
+    }
+    var baseMetricData = new Metric(logger, baseData.name, baseData.average, baseData.sampleCount, baseData.min, baseData.max, props, measurements);
+    var data = new Data(Metric.dataType, baseMetricData);
+    return _createEnvelope(logger, Metric.envelopeType, telemetryItem, data);
+}
+function PageViewEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
+    EnvelopeCreatorInit(logger, telemetryItem);
+    var strDuration = "duration";
+    var duration;
+    var baseData = telemetryItem[strBaseData];
+    if (!isNullOrUndefined(baseData) &&
+        !isNullOrUndefined(baseData[strProperties$1]) &&
+        !isNullOrUndefined(baseData[strProperties$1][strDuration])) {
+        duration = baseData[strProperties$1][strDuration];
+        delete baseData[strProperties$1][strDuration];
+    }
+    else if (!isNullOrUndefined(telemetryItem.data) &&
+        !isNullOrUndefined(telemetryItem.data[strDuration])) {
+        duration = telemetryItem.data[strDuration];
+        delete telemetryItem.data[strDuration];
+    }
+    var bd = telemetryItem[strBaseData];
+    var currentContextId;
+    if (((telemetryItem.ext || {}).trace || {}).traceID) {
+        currentContextId = telemetryItem.ext.trace.traceID;
+    }
+    var id = bd.id || currentContextId;
+    var name = bd.name;
+    var url = bd.uri;
+    var properties = bd[strProperties$1] || {};
+    var measurements = bd.measurements || {};
+    if (!isNullOrUndefined(bd.refUri)) {
+        properties["refUri"] = bd.refUri;
+    }
+    if (!isNullOrUndefined(bd.pageType)) {
+        properties["pageType"] = bd.pageType;
+    }
+    if (!isNullOrUndefined(bd.isLoggedIn)) {
+        properties["isLoggedIn"] = bd.isLoggedIn.toString();
+    }
+    if (!isNullOrUndefined(bd[strProperties$1])) {
+        var pageTags = bd[strProperties$1];
+        objForEachKey(pageTags, function (key, value) {
+            properties[key] = value;
+        });
+    }
+    _extractPropsAndMeasurements(telemetryItem.data, properties, measurements);
+    if (!isNullOrUndefined(customUndefinedValue)) {
+        _convertPropsUndefinedToCustomDefinedValue(properties, customUndefinedValue);
+    }
+    var pageViewData = new PageView(logger, name, url, duration, properties, measurements, id);
+    var data = new Data(PageView.dataType, pageViewData);
+    return _createEnvelope(logger, PageView.envelopeType, telemetryItem, data);
+}
+function PageViewPerformanceEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
+    EnvelopeCreatorInit(logger, telemetryItem);
+    var bd = telemetryItem[strBaseData];
+    var name = bd.name;
+    var url = bd.uri || bd.url;
+    var properties = bd[strProperties$1] || {};
+    var measurements = bd.measurements || {};
+    _extractPropsAndMeasurements(telemetryItem.data, properties, measurements);
+    if (!isNullOrUndefined(customUndefinedValue)) {
+        _convertPropsUndefinedToCustomDefinedValue(properties, customUndefinedValue);
+    }
+    var baseData = new PageViewPerformance(logger, name, url, undefined, properties, measurements, bd);
+    var data = new Data(PageViewPerformance.dataType, baseData);
+    return _createEnvelope(logger, PageViewPerformance.envelopeType, telemetryItem, data);
+}
+function TraceEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
+    EnvelopeCreatorInit(logger, telemetryItem);
+    var message = telemetryItem[strBaseData].message;
+    var severityLevel = telemetryItem[strBaseData].severityLevel;
+    var props = telemetryItem[strBaseData][strProperties$1] || {};
+    var measurements = telemetryItem[strBaseData].measurements || {};
+    _extractPropsAndMeasurements(telemetryItem.data, props, measurements);
+    if (!isNullOrUndefined(customUndefinedValue)) {
+        _convertPropsUndefinedToCustomDefinedValue(props, customUndefinedValue);
+    }
+    var baseData = new Trace(logger, message, severityLevel, props, measurements);
+    var data = new Data(Trace.dataType, baseData);
+    return _createEnvelope(logger, Trace.envelopeType, telemetryItem, data);
+}
 
 var Serializer = /** @class */ (function () {
     function Serializer(logger) {
@@ -5622,8 +5651,8 @@ var OfflineListener = /** @class */ (function () {
         dynamicProto(OfflineListener, this, function (_self) {
             try {
                 if (_window) {
-                    if (EventHelper.Attach(_window, 'online', _setOnline)) {
-                        EventHelper.Attach(_window, 'offline', _setOffline);
+                    if (attachEvent(_window, 'online', _setOnline)) {
+                        attachEvent(_window, 'offline', _setOffline);
                         isListening = true;
                     }
                 }
@@ -5673,6 +5702,7 @@ var OfflineListener = /** @class */ (function () {
 }());
 var Offline = OfflineListener.Offline;
 
+var MIN_INPUT_LENGTH = 8;
 var HashCodeScoreGenerator = /** @class */ (function () {
     function HashCodeScoreGenerator() {
     }
@@ -5684,7 +5714,7 @@ var HashCodeScoreGenerator = /** @class */ (function () {
         if (input === "") {
             return 0;
         }
-        while (input.length < HashCodeScoreGenerator.MIN_INPUT_LENGTH) {
+        while (input.length < MIN_INPUT_LENGTH) {
             input = input.concat(input);
         }
         var hash = 5381;
@@ -5695,43 +5725,43 @@ var HashCodeScoreGenerator = /** @class */ (function () {
         return Math.abs(hash);
     };
     HashCodeScoreGenerator.INT_MAX_VALUE = 2147483647;
-    HashCodeScoreGenerator.MIN_INPUT_LENGTH = 8;
     return HashCodeScoreGenerator;
 }());
 
 var SamplingScoreGenerator = /** @class */ (function () {
     function SamplingScoreGenerator() {
-        this.hashCodeGeneragor = new HashCodeScoreGenerator();
-        this.keys = new ContextTagKeys();
+        var _self = this;
+        var hashCodeGenerator = new HashCodeScoreGenerator();
+        var keys = new ContextTagKeys();
+        _self.getSamplingScore = function (item) {
+            var score = 0;
+            if (item.tags && item.tags[keys.userId]) {
+                score = hashCodeGenerator.getHashCodeScore(item.tags[keys.userId]);
+            }
+            else if (item.ext && item.ext.user && item.ext.user.id) {
+                score = hashCodeGenerator.getHashCodeScore(item.ext.user.id);
+            }
+            else if (item.tags && item.tags[keys.operationId]) {
+                score = hashCodeGenerator.getHashCodeScore(item.tags[keys.operationId]);
+            }
+            else if (item.ext && item.ext.telemetryTrace && item.ext.telemetryTrace.traceID) {
+                score = hashCodeGenerator.getHashCodeScore(item.ext.telemetryTrace.traceID);
+            }
+            else {
+                score = (Math.random() * 100);
+            }
+            return score;
+        };
     }
-    SamplingScoreGenerator.prototype.getSamplingScore = function (item) {
-        var score = 0;
-        if (item.tags && item.tags[this.keys.userId]) {
-            score = this.hashCodeGeneragor.getHashCodeScore(item.tags[this.keys.userId]);
-        }
-        else if (item.ext && item.ext.user && item.ext.user.id) {
-            score = this.hashCodeGeneragor.getHashCodeScore(item.ext.user.id);
-        }
-        else if (item.tags && item.tags[this.keys.operationId]) {
-            score = this.hashCodeGeneragor.getHashCodeScore(item.tags[this.keys.operationId]);
-        }
-        else if (item.ext && item.ext.telemetryTrace && item.ext.telemetryTrace.traceID) {
-            score = this.hashCodeGeneragor.getHashCodeScore(item.ext.telemetryTrace.traceID);
-        }
-        else {
-            score = (Math.random() * 100);
-        }
-        return score;
-    };
     return SamplingScoreGenerator;
 }());
 
 var Sample = /** @class */ (function () {
     function Sample(sampleRate, logger) {
         this.INT_MAX_VALUE = 2147483647;
-        this._logger = logger || safeGetLogger(null);
+        var _logger = logger || safeGetLogger(null);
         if (sampleRate > 100 || sampleRate < 0) {
-            this._logger.throwInternal(LoggingSeverity.WARNING, _InternalMessageId.SampleRateOutOfRange, "Sampling rate is out of range (0..100). Sampling will be disabled, you may be sending too much data which may affect your AI service level.", { samplingRate: sampleRate }, true);
+            _logger.throwInternal(LoggingSeverity.WARNING, _InternalMessageId.SampleRateOutOfRange, "Sampling rate is out of range (0..100). Sampling will be disabled, you may be sending too much data which may affect your AI service level.", { samplingRate: sampleRate }, true);
             sampleRate = 100;
         }
         this.sampleRate = sampleRate;
@@ -5752,6 +5782,8 @@ var Sample = /** @class */ (function () {
     return Sample;
 }());
 
+var _a;
+var FetchSyncRequestSizeLimitBytes = 65000;
 function _getResponseText(xhr) {
     try {
         return xhr.responseText;
@@ -5760,13 +5792,41 @@ function _getResponseText(xhr) {
     }
     return null;
 }
+function _getDefaultAppInsightsChannelConfig() {
+    return {
+        endpointUrl: function () { return "https://dc.services.visualstudio.com/v2/track"; },
+        emitLineDelimitedJson: function () { return false; },
+        maxBatchInterval: function () { return 15000; },
+        maxBatchSizeInBytes: function () { return 102400; },
+        disableTelemetry: function () { return false; },
+        enableSessionStorageBuffer: function () { return true; },
+        isRetryDisabled: function () { return false; },
+        isBeaconApiDisabled: function () { return true; },
+        disableXhr: function () { return false; },
+        onunloadDisableFetch: function () { return false; },
+        onunloadDisableBeacon: function () { return false; },
+        instrumentationKey: function () { return undefined; },
+        namePrefix: function () { return undefined; },
+        samplingPercentage: function () { return 100; },
+        customHeaders: function () { return undefined; },
+        convertUndefined: function () { return undefined; }
+    };
+}
+var EnvelopeTypeCreator = (_a = {},
+    _a[Event$1.dataType] = EventEnvelopeCreator,
+    _a[Trace.dataType] = TraceEnvelopeCreator,
+    _a[PageView.dataType] = PageViewEnvelopeCreator,
+    _a[PageViewPerformance.dataType] = PageViewPerformanceEnvelopeCreator,
+    _a[Exception.dataType] = ExceptionEnvelopeCreator,
+    _a[Metric.dataType] = MetricEnvelopeCreator,
+    _a[RemoteDependencyData.dataType] = DependencyEnvelopeCreator,
+    _a);
 var Sender = /** @class */ (function (_super) {
     __extendsFn(Sender, _super);
     function Sender() {
         var _this = _super.call(this) || this;
         _this.priority = 1001;
         _this.identifier = BreezeChannelIdentifier;
-        _this._XMLHttpRequestSupported = false;
         var _consecutiveErrors;
         var _retryAt;
         var _lastSend;
@@ -5774,6 +5834,10 @@ var Sender = /** @class */ (function (_super) {
         var _serializer;
         var _stamp_specific_redirects;
         var _headers = {};
+        var _syncFetchPayload = 0;
+        var _fallbackSender;
+        var _syncUnloadSender;
+        _this._senderConfig = _getDefaultAppInsightsChannelConfig();
         dynamicProto(Sender, _this, function (_self, _base) {
             function _notImplemented() {
                 throwError("Method not implemented.");
@@ -5789,9 +5853,9 @@ var Sender = /** @class */ (function (_super) {
                 }
             };
             _self.onunloadFlush = function () {
-                if ((_self._senderConfig.onunloadDisableBeacon() === false || _self._senderConfig.isBeaconApiDisabled() === false) && isBeaconApiSupported()) {
+                if ((_self._senderConfig.onunloadDisableBeacon() === false || _self._senderConfig.isBeaconApiDisabled() === false) && isBeaconsSupported()) {
                     try {
-                        _self.triggerSend(true, _beaconSender, 2 );
+                        _self.triggerSend(true, _doUnloadSend, 2 );
                     }
                     catch (e) {
                         _self.diagLog().throwInternal(LoggingSeverity.CRITICAL, _InternalMessageId.FailedToSendQueuedTelemetry, "failed to flush with beacon sender on page unload, telemetry will not be collected: " + getExceptionName(e), { exception: dumpObj(e) });
@@ -5815,8 +5879,7 @@ var Sender = /** @class */ (function (_super) {
                 _lastSend = 0;
                 _self._sender = null;
                 _stamp_specific_redirects = 0;
-                var defaultConfig = Sender._getDefaultAppInsightsChannelConfig();
-                _self._senderConfig = Sender._getEmptyAppInsightsChannelConfig();
+                var defaultConfig = _getDefaultAppInsightsChannelConfig();
                 objForEachKey(defaultConfig, function (field, value) {
                     _self._senderConfig[field] = function () { return ctx.getConfig(identifier, field, value()); };
                 });
@@ -5831,27 +5894,36 @@ var Sender = /** @class */ (function (_super) {
                         _this.addHeader(customHeader.header, customHeader.value);
                     });
                 }
-                if (!_self._senderConfig.isBeaconApiDisabled() && isBeaconApiSupported()) {
-                    _self._sender = _beaconSender;
+                var senderConfig = _self._senderConfig;
+                var sendPostFunc = null;
+                if (!senderConfig.disableXhr() && useXDomainRequest()) {
+                    sendPostFunc = _xdrSender;
+                }
+                else if (!senderConfig.disableXhr() && isXhrSupported()) {
+                    sendPostFunc = _xhrSender;
+                }
+                if (!sendPostFunc && isFetchSupported()) {
+                    sendPostFunc = _fetchSender;
+                }
+                _fallbackSender = sendPostFunc || _xhrSender;
+                if (!senderConfig.isBeaconApiDisabled() && isBeaconsSupported()) {
+                    sendPostFunc = _beaconSender;
+                }
+                _self._sender = sendPostFunc || _xhrSender;
+                if (!senderConfig.onunloadDisableFetch() && isFetchSupported(true)) {
+                    _syncUnloadSender = _fetchKeepAliveSender;
+                }
+                else if (isBeaconsSupported()) {
+                    _syncUnloadSender = _beaconSender;
+                }
+                else if (!senderConfig.disableXhr() && useXDomainRequest()) {
+                    _syncUnloadSender = _xdrSender;
+                }
+                else if (!senderConfig.disableXhr() && isXhrSupported()) {
+                    _syncUnloadSender = _xhrSender;
                 }
                 else {
-                    var xhr = getGlobalInst("XMLHttpRequest");
-                    if (xhr) {
-                        var testXhr = new xhr();
-                        if ("withCredentials" in testXhr) {
-                            _self._sender = _xhrSender;
-                            _self._XMLHttpRequestSupported = true;
-                        }
-                        else if (typeof XDomainRequest !== strShimUndefined) {
-                            _self._sender = _xdrSender;
-                        }
-                    }
-                    else {
-                        var fetch_1 = getGlobalInst("fetch");
-                        if (fetch_1) {
-                            _self._sender = _fetchSender;
-                        }
-                    }
+                    _syncUnloadSender = _fallbackSender;
                 }
             };
             _self.processTelemetry = function (telemetryItem, itemCtx) {
@@ -5883,7 +5955,8 @@ var Sender = /** @class */ (function (_super) {
                         telemetryItem[SampleRate] = _self._sample.sampleRate;
                     }
                     var convertUndefined = _self._senderConfig.convertUndefined() || undefined;
-                    var aiEnvelope_1 = Sender.constructEnvelope(telemetryItem, _self._senderConfig.instrumentationKey(), itemCtx.diagLog(), convertUndefined);
+                    var defaultEnvelopeIkey = telemetryItem.iKey || _self._senderConfig.instrumentationKey();
+                    var aiEnvelope_1 = Sender.constructEnvelope(telemetryItem, defaultEnvelopeIkey, itemCtx.diagLog(), convertUndefined);
                     if (!aiEnvelope_1) {
                         itemCtx.diagLog().throwInternal(LoggingSeverity.CRITICAL, _InternalMessageId.CreateEnvelopeError, "Unable to create an AppInsights envelope");
                         return;
@@ -5907,12 +5980,12 @@ var Sender = /** @class */ (function (_super) {
                         return;
                     }
                     var payload = _serializer.serialize(aiEnvelope_1);
-                    var bufferPayload = _self._buffer.getItems();
-                    var batch = _self._buffer.batchPayloads(bufferPayload);
-                    if (batch && (batch.length + payload.length > _self._senderConfig.maxBatchSizeInBytes())) {
+                    var buffer = _self._buffer;
+                    var bufferSize = buffer.size();
+                    if ((bufferSize + payload.length) > _self._senderConfig.maxBatchSizeInBytes()) {
                         _self.triggerSend(true, null, 10 );
                     }
-                    _self._buffer.enqueue(payload);
+                    buffer.enqueue(payload);
                     _setupTimer();
                 }
                 catch (e) {
@@ -5928,9 +6001,10 @@ var Sender = /** @class */ (function (_super) {
             _self.triggerSend = function (async, forcedSender, sendReason) {
                 if (async === void 0) { async = true; }
                 try {
+                    var buffer = _self._buffer;
                     if (!_self._senderConfig.disableTelemetry()) {
-                        if (_self._buffer.count() > 0) {
-                            var payload = _self._buffer.getItems();
+                        if (buffer.count() > 0) {
+                            var payload = buffer.getItems();
                             _notifySendRequest(sendReason || 0 , async);
                             if (forcedSender) {
                                 forcedSender.call(_this, payload, async);
@@ -5942,7 +6016,7 @@ var Sender = /** @class */ (function (_super) {
                         _lastSend = +new Date;
                     }
                     else {
-                        _self._buffer.clear();
+                        buffer.clear();
                     }
                     clearTimeout(_timeoutHandle);
                     _timeoutHandle = null;
@@ -6072,18 +6146,42 @@ var Sender = /** @class */ (function (_super) {
                 }
                 return false;
             }
-            function _beaconSender(payload, isAsync) {
+            function _doUnloadSend(payload, isAsync) {
+                if (_syncUnloadSender) {
+                    _syncUnloadSender(payload, false);
+                }
+                else {
+                    _beaconSender(payload);
+                }
+            }
+            function _doBeaconSend(payload) {
+                var nav = getNavigator();
+                var buffer = _self._buffer;
                 var url = _self._senderConfig.endpointUrl();
                 var batch = _self._buffer.batchPayloads(payload);
                 var plainTextBatch = new Blob([batch], { type: 'text/plain;charset=UTF-8' });
-                var queued = getNavigator().sendBeacon(url, plainTextBatch);
+                var queued = nav.sendBeacon(url, plainTextBatch);
                 if (queued) {
-                    _self._buffer.markAsSent(payload);
+                    buffer.markAsSent(payload);
                     _self._onSuccess(payload, payload.length);
                 }
-                else {
-                    _xhrSender(payload, true);
-                    _self.diagLog().throwInternal(LoggingSeverity.WARNING, _InternalMessageId.TransmissionFailed, ". " + "Failed to send telemetry with Beacon API, retried with xhrSender.");
+                return queued;
+            }
+            function _beaconSender(payload, isAsync) {
+                if (isArray(payload) && payload.length > 0) {
+                    if (!_doBeaconSend(payload)) {
+                        var droppedPayload = [];
+                        for (var lp = 0; lp < payload.length; lp++) {
+                            var thePayload = payload[lp];
+                            if (!_doBeaconSend([thePayload])) {
+                                droppedPayload.push(thePayload);
+                            }
+                        }
+                        if (droppedPayload.length > 0) {
+                            _fallbackSender(droppedPayload, true);
+                            _self.diagLog().throwInternal(LoggingSeverity.WARNING, _InternalMessageId.TransmissionFailed, ". " + "Failed to send telemetry with Beacon API, retried with normal sender.");
+                        }
+                    }
                 }
             }
             function _xhrSender(payload, isAsync) {
@@ -6108,36 +6206,79 @@ var Sender = /** @class */ (function (_super) {
                 xhr.send(batch);
                 _self._buffer.markAsSent(payload);
             }
+            function _fetchKeepAliveSender(payload, isAsync) {
+                if (isArray(payload)) {
+                    var payloadSize = payload.length;
+                    for (var lp = 0; lp < payload.length; lp++) {
+                        payloadSize += payload[lp].length;
+                    }
+                    if ((_syncFetchPayload + payloadSize) <= FetchSyncRequestSizeLimitBytes) {
+                        _doFetchSender(payload, false);
+                    }
+                    else if (isBeaconsSupported()) {
+                        _beaconSender(payload);
+                    }
+                    else {
+                        _fallbackSender && _fallbackSender(payload, true);
+                        _self.diagLog().throwInternal(LoggingSeverity.WARNING, _InternalMessageId.TransmissionFailed, ". " + "Failed to send telemetry with Beacon API, retried with xhrSender.");
+                    }
+                }
+            }
             function _fetchSender(payload, isAsync) {
+                _doFetchSender(payload, true);
+            }
+            function _doFetchSender(payload, isAsync) {
+                var _a;
                 var endPointUrl = _self._senderConfig.endpointUrl();
                 var batch = _self._buffer.batchPayloads(payload);
-                var plainTextBatch = new Blob([batch], { type: 'text/plain;charset=UTF-8' });
+                var plainTextBatch = new Blob([batch], { type: 'application/json' });
                 var requestHeaders = new Headers();
+                var batchLength = batch.length;
                 if (isInternalApplicationInsightsEndpoint(endPointUrl)) {
                     requestHeaders.append(RequestHeaders.sdkContextHeader, RequestHeaders.sdkContextHeaderAppIdRequest);
                 }
                 arrForEach(objKeys(_headers), function (headerName) {
                     requestHeaders.append(headerName, _headers[headerName]);
                 });
-                var init = {
-                    method: "POST",
-                    headers: requestHeaders,
-                    body: plainTextBatch
-                };
+                var init = (_a = {
+                        method: "POST",
+                        headers: requestHeaders,
+                        body: plainTextBatch
+                    },
+                    _a[DisabledPropertyName] = true
+                ,
+                    _a);
+                if (!isAsync) {
+                    init.keepalive = true;
+                    _syncFetchPayload += batchLength;
+                }
                 var request = new Request(endPointUrl, init);
+                try {
+                    request[DisabledPropertyName] = true;
+                }
+                catch (e) {
+                }
                 fetch(request).then(function (response) {
+                    if (!isAsync) {
+                        _syncFetchPayload -= batchLength;
+                        batchLength = 0;
+                    }
                     if (!response.ok) {
-                        throw Error(response.statusText);
+                        _self._onError(payload, response.statusText);
                     }
                     else {
                         response.text().then(function (text) {
                             _checkResponsStatus(response.status, payload, response.url, payload.length, response.statusText, text);
                         });
-                        _self._buffer.markAsSent(payload);
                     }
                 })["catch"](function (error) {
+                    if (!isAsync) {
+                        _syncFetchPayload -= batchLength;
+                        batchLength = 0;
+                    }
                     _self._onError(payload, error.message);
                 });
+                _self._buffer.markAsSent(payload);
             }
             function _parseResponse(response) {
                 try {
@@ -6161,11 +6302,12 @@ var Sender = /** @class */ (function (_super) {
                 if (!payload || payload.length === 0) {
                     return;
                 }
-                _self._buffer.clearSent(payload);
+                var buffer = _self._buffer;
+                buffer.clearSent(payload);
                 _consecutiveErrors++;
                 for (var _i = 0, payload_1 = payload; _i < payload_1.length; _i++) {
                     var item = payload_1[_i];
-                    _self._buffer.enqueue(item);
+                    buffer.enqueue(item);
                 }
                 _setRetryTime(linearFactor);
                 _setupTimer();
@@ -6207,6 +6349,7 @@ var Sender = /** @class */ (function (_super) {
                 return message;
             }
             function _xdrSender(payload, isAsync) {
+                var buffer = _self._buffer;
                 var _window = getWindow();
                 var xdr = new XDomainRequest();
                 xdr.onload = function () { return _self._xdrOnLoad(xdr, payload); };
@@ -6215,14 +6358,14 @@ var Sender = /** @class */ (function (_super) {
                 if (_self._senderConfig.endpointUrl().lastIndexOf(hostingProtocol, 0) !== 0) {
                     _self.diagLog().throwInternal(LoggingSeverity.WARNING, _InternalMessageId.TransmissionFailed, ". " +
                         "Cannot send XDomain request. The endpoint URL protocol doesn't match the hosting page protocol.");
-                    _self._buffer.clear();
+                    buffer.clear();
                     return;
                 }
                 var endpointUrl = _self._senderConfig.endpointUrl().replace(/^(https?:)/, "");
                 xdr.open('POST', endpointUrl);
-                var batch = _self._buffer.batchPayloads(payload);
+                var batch = buffer.batchPayloads(payload);
                 xdr.send(batch);
-                _self._buffer.markAsSent(payload);
+                buffer.markAsSent(payload);
             }
             function _formatErrorMessageXdr(xdr, message) {
                 if (xdr) {
@@ -6268,60 +6411,8 @@ var Sender = /** @class */ (function (_super) {
         else {
             envelope = orig;
         }
-        switch (envelope.baseType) {
-            case Event$1.dataType:
-                return EventEnvelopeCreator.EventEnvelopeCreator.Create(logger, envelope, convertUndefined);
-            case Trace.dataType:
-                return TraceEnvelopeCreator.TraceEnvelopeCreator.Create(logger, envelope, convertUndefined);
-            case PageView.dataType:
-                return PageViewEnvelopeCreator.PageViewEnvelopeCreator.Create(logger, envelope, convertUndefined);
-            case PageViewPerformance.dataType:
-                return PageViewPerformanceEnvelopeCreator.PageViewPerformanceEnvelopeCreator.Create(logger, envelope, convertUndefined);
-            case Exception.dataType:
-                return ExceptionEnvelopeCreator.ExceptionEnvelopeCreator.Create(logger, envelope, convertUndefined);
-            case Metric.dataType:
-                return MetricEnvelopeCreator.MetricEnvelopeCreator.Create(logger, envelope, convertUndefined);
-            case RemoteDependencyData.dataType:
-                return DependencyEnvelopeCreator.DependencyEnvelopeCreator.Create(logger, envelope, convertUndefined);
-            default:
-                return EventEnvelopeCreator.EventEnvelopeCreator.Create(logger, envelope, convertUndefined);
-        }
-    };
-    Sender._getDefaultAppInsightsChannelConfig = function () {
-        return {
-            endpointUrl: function () { return "https://dc.services.visualstudio.com/v2/track"; },
-            emitLineDelimitedJson: function () { return false; },
-            maxBatchInterval: function () { return 15000; },
-            maxBatchSizeInBytes: function () { return 102400; },
-            disableTelemetry: function () { return false; },
-            enableSessionStorageBuffer: function () { return true; },
-            isRetryDisabled: function () { return false; },
-            isBeaconApiDisabled: function () { return true; },
-            onunloadDisableBeacon: function () { return false; },
-            instrumentationKey: function () { return undefined; },
-            namePrefix: function () { return undefined; },
-            samplingPercentage: function () { return 100; },
-            customHeaders: function () { return undefined; },
-            convertUndefined: function () { return undefined; }
-        };
-    };
-    Sender._getEmptyAppInsightsChannelConfig = function () {
-        return {
-            endpointUrl: undefined,
-            emitLineDelimitedJson: undefined,
-            maxBatchInterval: undefined,
-            maxBatchSizeInBytes: undefined,
-            disableTelemetry: undefined,
-            enableSessionStorageBuffer: undefined,
-            isRetryDisabled: undefined,
-            isBeaconApiDisabled: undefined,
-            onunloadDisableBeacon: undefined,
-            instrumentationKey: undefined,
-            namePrefix: undefined,
-            samplingPercentage: undefined,
-            customHeaders: undefined,
-            convertUndefined: undefined
-        };
+        var creator = EnvelopeTypeCreator[envelope.baseType] || EventEnvelopeCreator;
+        return creator(logger, envelope, convertUndefined);
     };
     return Sender;
 }(BaseTelemetryPlugin));
@@ -6478,7 +6569,7 @@ var Device = /** @class */ (function () {
     return Device;
 }());
 
-var Version = "2.7.0-beta.1";
+var Version = "2.7.1-nightly.202110-04";
 var Internal = /** @class */ (function () {
     function Internal(config) {
         this.sdkVersion = (config.sdkExtension && config.sdkExtension() ? config.sdkExtension() + "_" : "") + "javascript:" + Version;
@@ -7010,7 +7101,7 @@ var ajaxRecord = /** @class */ (function () {
                                 dependency[strProperties].responseHeaders = response.headerMap;
                             }
                         }
-                        if (self.status >= 400) {
+                        if (self.errorStatusText && self.status >= 400) {
                             var responseType = response.type;
                             dependency[strProperties] = dependency[strProperties] || {};
                             if (responseType === "" || responseType === "text") {
@@ -7080,7 +7171,7 @@ function _supportsFetch() {
 }
 function _supportsAjaxMonitoring(ajaxMonitorInstance) {
     var result = false;
-    if (typeof XMLHttpRequest !== strShimUndefined && !isNullOrUndefined(XMLHttpRequest)) {
+    if (isXhrSupported()) {
         var proto = XMLHttpRequest[strShimPrototype];
         result = !isNullOrUndefined(proto) &&
             !isNullOrUndefined(proto.open) &&
@@ -7153,6 +7244,7 @@ var AjaxMonitor = /** @class */ (function (_super) {
         var _currentWindowHost = location && location.host && location.host.toLowerCase();
         var _config = AjaxMonitor.getEmptyConfig();
         var _enableRequestHeaderTracking = false;
+        var _enableAjaxErrorStatusText = false;
         var _trackAjaxAttempts = 0;
         var _context;
         var _isUsingW3CHeaders;
@@ -7176,6 +7268,7 @@ var AjaxMonitor = /** @class */ (function (_super) {
                     });
                     var distributedTracingMode = _config.distributedTracingMode;
                     _enableRequestHeaderTracking = _config.enableRequestHeaderTracking;
+                    _enableAjaxErrorStatusText = _config.enableAjaxErrorStatusText;
                     _enableAjaxPerfTracking = _config.enableAjaxPerfTracking;
                     _maxAjaxCallsPerView = _config.maxAjaxCallsPerView;
                     _enableResponseHeaderTracking = _config.enableResponseHeaderTracking;
@@ -7462,6 +7555,9 @@ var AjaxMonitor = /** @class */ (function (_super) {
                     isDisabled = (typeof request === 'object' ? request[DisabledPropertyName] === true : false) ||
                         (init ? init[DisabledPropertyName] === true : false);
                 }
+                if (!isDisabled && theUrl && isInternalApplicationInsightsEndpoint(theUrl)) {
+                    isDisabled = true;
+                }
                 if (isDisabled) {
                     if (!_disabledUrls[theUrl]) {
                         _disabledUrls[theUrl] = 1;
@@ -7492,11 +7588,12 @@ var AjaxMonitor = /** @class */ (function (_super) {
                 ajaxData.xhrMonitoringState.openDone = true;
                 ajaxData.requestHeaders = {};
                 ajaxData.async = async;
+                ajaxData.errorStatusText = _enableAjaxErrorStatusText;
                 xhr[strAjaxData] = ajaxData;
                 _attachToOnReadyStateChange(xhr);
             }
             function _attachToOnReadyStateChange(xhr) {
-                xhr[strAjaxData].xhrMonitoringState.stateChangeAttached = EventHelper.Attach(xhr, "readystatechange", function () {
+                xhr[strAjaxData].xhrMonitoringState.stateChangeAttached = attachEvent(xhr, "readystatechange", function () {
                     try {
                         if (xhr && xhr.readyState === 4 && _isMonitoredXhrInstance(xhr)) {
                             _onAjaxComplete(xhr);
@@ -7686,6 +7783,7 @@ var AjaxMonitor = /** @class */ (function (_super) {
                 var spanID = generateW3CId().substr(0, 16);
                 var ajaxData = new ajaxRecord(traceID, spanID, _self[strDiagLog]());
                 ajaxData.requestSentTime = dateTimeUtilsNow();
+                ajaxData.errorStatusText = _enableAjaxErrorStatusText;
                 if (input instanceof Request) {
                     ajaxData.requestUrl = input ? input.url : "";
                 }
@@ -7837,7 +7935,7 @@ var AjaxMonitor = /** @class */ (function (_super) {
 
 var _internalSdkSrc;
 var _ignoreUpdateSnippetProperties = [
-    "snippet", "dependencies", "properties", "_snippetVersion", "appInsightsNew", "getSKUDefaults",
+    "snippet", "dependencies", "properties", "_snippetVersion", "appInsightsNew", "getSKUDefaults"
 ];
 var fieldType = {
     Default: 0 ,
@@ -7919,11 +8017,11 @@ var Initialization = /** @class */ (function () {
         var inPvp = pageViewPerformance || {};
         this.appInsights.trackPageViewPerformance(inPvp);
     };
-    Initialization.prototype.trackException = function (exception) {
+    Initialization.prototype.trackException = function (exception, customProperties) {
         if (exception && !exception.exception && exception.error) {
             exception.exception = exception.error;
         }
-        this.appInsights.trackException(exception);
+        this.appInsights.trackException(exception, customProperties);
     };
     Initialization.prototype._onerror = function (exception) {
         this.appInsights._onerror(exception);
@@ -8058,6 +8156,9 @@ var Initialization = /** @class */ (function () {
     Initialization.prototype.pollInternalLogs = function () {
         this.core.pollInternalLogs();
     };
+    Initialization.prototype.stopPollingInternalLogs = function () {
+        this.core.stopPollingInternalLogs();
+    };
     Initialization.prototype.addHousekeepingBeforeUnload = function (appInsightsInstance) {
         if (hasWindow() || hasDocument()) {
             var performHousekeeping = function () {
@@ -8194,4 +8295,4 @@ catch (e) {
 
 exports.ApplicationInsights = Initialization;
 exports.Telemetry = Telemetry;
-//# sourceMappingURL=ai.2.7.0-beta.1.cjs.js.map
+//# sourceMappingURL=ai.2.7.1-nightly.202110-04.cjs.js.map