@microsoft/applicationinsights-dependencies-js 3.4.0-nightlybeta3.2505-36 → 3.4.0-nightlybeta3.2507-23

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

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Dependencies Plugin, 3.4.0-nightlybeta3.2505-36
+ * Application Insights JavaScript SDK - Dependencies Plugin, 3.4.0-nightlybeta3.2507-23
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -39,6 +39,7 @@
     var CALL = "call";
     var TO_STRING = "toString";
     var GET_OWN_PROPERTY_DESCRIPTOR = "getOwnPropertyDescriptor";
+    var GET_OWN_PROPERTY_SYMBOLS = "getOwnPropertySymbols";
     var ObjClass = ( /*#__PURE__*/_pureAssign(Object));
     var ObjProto = ( /*#__PURE__*/_pureRef(ObjClass, PROTOTYPE));
     var StrCls = ( /*#__PURE__*/_pureAssign(String));
@@ -111,6 +112,9 @@
     function _returnNothing() {
         return;
     }
+    function _returnEmptyArray() {
+        return [];
+    }
     var asString = ( /*#__PURE__*/_pureAssign(StrCls));
     var ERROR_TYPE = "[object Error]";
     /*#__NO_SIDE_EFFECTS__*/
@@ -187,7 +191,26 @@
             throwTypeError("\"" + asString(funcName) + "\" not defined for " + dumpObj(thisArg));
         };
     }
+    function _objPropertyIsEnum(obj, propKey) {
+        var desc;
+        var fn = ObjClass.getOwnPropertyDescriptor;
+        if (!isStrictNullOrUndefined(obj) && fn) {
+            desc = safe(fn, [obj, propKey]).v || NULL_VALUE;
+        }
+        if (!desc) {
+            desc = safe(function () {
+                for (var key in obj) {
+                    if (key === propKey) {
+                        return { enumerable: true };
+                    }
+                }
+            }).v;
+        }
+        return (desc && desc.enumerable) || false;
+    }
+    var objPropertyIsEnumerable = ( /*#__PURE__*/_unwrapFunctionWithPoly("propertyIsEnumerable", NULL_VALUE, _objPropertyIsEnum));
     var _objGetOwnPropertyDescriptor$1 = ( /*#__PURE__*/_pureAssign(( /*#__PURE__*/_pureRef(ObjClass, GET_OWN_PROPERTY_DESCRIPTOR)), _returnNothing));
+    var _objGetOwnPropertySymbols = ( /*#__PURE__*/_pureAssign(( /*#__PURE__*/_pureRef(ObjClass, GET_OWN_PROPERTY_SYMBOLS)), _returnEmptyArray));
     var propMap = {
         e: "enumerable",
         c: "configurable",
@@ -220,6 +243,18 @@
     function objDefine(target, key, propDesc) {
         return objDefineProp(target, key, _createProp(propDesc));
     }
+    function objDefineProps(target, propDescMap) {
+        var props = {};
+        objForEachKey(propDescMap, function (key, value) {
+            props[key] = _createProp(value);
+        });
+        arrForEach(_objGetOwnPropertySymbols(propDescMap), function (sym) {
+            if (objPropertyIsEnumerable(propDescMap, sym)) {
+                props[sym] = _createProp(propDescMap[sym]);
+            }
+        });
+        return objDefineProperties(target, props);
+    }
     /*#__NO_SIDE_EFFECTS__*/
     function _createKeyValueMap(values, keyType, valueType, completeFn, writable) {
         var theMap = {};
@@ -478,6 +513,22 @@
             toJSON: function () { return value; }
         }, "v", { value: value });
     }
+    var createDeferredCachedValue = getDeferred;
+    /*#__NO_SIDE_EFFECTS__*/
+    function getDeferred(cb, argArray) {
+        var theValue = {
+            toJSON: function () { return theValue.v; }
+        };
+        return objDefineProp(theValue, "v", {
+            get: function () {
+                var result = fnApply(cb, null, argArray);
+                cb = NULL_VALUE;
+                objDefineProp(theValue, "v", { value: result });
+                return result;
+            },
+            configurable: true
+        });
+    }
     var WINDOW = "window";
     var _cachedGlobal;
     function _getGlobalInstFn(getFn, theArgs) {
@@ -1140,11 +1191,15 @@
     var _DYN_CANCEL = "cancel";
     var _DYN_INITIALIZE = "initialize";
     var _DYN_IDENTIFIER = "identifier";
+    var _DYN_TRACE_ID$1 = "traceId";
+    var _DYN_SPAN_ID$1 = "spanId";
+    var _DYN_TRACE_FLAGS$2 = "traceFlags";
     var _DYN_IS_INITIALIZED = "isInitialized";
     var _DYN_GET_PLUGIN = "getPlugin";
     var _DYN_NAME$1 = "name";
     var _DYN_PROCESS_NEXT = "processNext";
     var _DYN_GET_PROCESS_TEL_CONT2 = "getProcessTelContext";
+    var _DYN_VALUE = "value";
     var _DYN_UNLOAD = "unload";
     var _DYN_VERSION = "version";
     var _DYN_LOGGING_LEVEL_CONSOL4 = "loggingLevelConsole";
@@ -1160,11 +1215,14 @@
     var _DYN_USER_AGENT = "userAgent";
     var _DYN_SPLIT$1 = "split";
     var _DYN_REPLACE = "replace";
+    var _DYN_SUBSTRING = "substring";
+    var _DYN_INDEX_OF = "indexOf";
     var _DYN_TYPE = "type";
     var _DYN_IS_CHILD_EVT = "isChildEvt";
     var _DYN_GET_CTX = "getCtx";
     var _DYN_SET_CTX = "setCtx";
-    var _DYN_TRACE_FLAGS$1 = "traceFlags";
+    var _DYN_SET_TRACE_FLAGS = "setTraceFlags";
+    var _DYN_TRACE_STATE$1 = "traceState";
 
     var aggregationErrorType;
     function throwAggregationError(message, sourceErrors) {
@@ -1191,6 +1249,8 @@
     var STR_PRIORITY = "priority";
     var STR_GET_PERF_MGR = "getPerfMgr";
     var STR_NOT_DYNAMIC_ERROR = "Not dynamic - ";
+    var STR_REDACTED = "REDACTED";
+    var DEFAULT_SENSITIVE_PARAMS = ["sig", "Signature", "AWSAccessKeyId", "X-Goog-Signature"];
 
     var strGetPrototypeOf = "getPrototypeOf";
     var rCamelCase = /-([a-z])/g;
@@ -1351,6 +1411,110 @@
         }
         return isSupported;
     }
+    function redactUserInfo(url) {
+        return url.replace(/^([a-zA-Z][a-zA-Z0-9+.-]*:\/\/)([^:@]{1,200}):([^@]{1,200})@(.*)$/, "$1REDACTED:REDACTED@$4");
+    }
+    function redactQueryParameters(url, config) {
+        var sensitiveParams;
+        var questionMarkIndex = strIndexOf(url, "?");
+        if (questionMarkIndex === -1) {
+            return url;
+        }
+        if (config && config.redactQueryParams) {
+            sensitiveParams = DEFAULT_SENSITIVE_PARAMS.concat(config.redactQueryParams);
+        }
+        else {
+            sensitiveParams = DEFAULT_SENSITIVE_PARAMS;
+        }
+        var baseUrl = strSubstring(url, 0, questionMarkIndex + 1);
+        var queryString = strSubstring(url, questionMarkIndex + 1);
+        var fragment = STR_EMPTY;
+        var hashIndex = strIndexOf(queryString, "#");
+        if (hashIndex !== -1) {
+            fragment = strSubstring(queryString, hashIndex);
+            queryString = strSubstring(queryString, 0, hashIndex);
+        }
+        var hasPotentialSensitiveParam = false;
+        for (var i = 0; i < sensitiveParams[_DYN_LENGTH$2 ]; i++) {
+            var paramCheck = sensitiveParams[i] + "=";
+            if (strIndexOf(queryString, paramCheck) !== -1) {
+                hasPotentialSensitiveParam = true;
+                break;
+            }
+        }
+        if (!hasPotentialSensitiveParam) {
+            return url;
+        }
+        var resultParts = [];
+        var anyParamRedacted = false;
+        if (queryString && queryString[_DYN_LENGTH$2 ]) {
+            var pairs = queryString[_DYN_SPLIT$1 ]("&");
+            for (var i = 0; i < pairs[_DYN_LENGTH$2 ]; i++) {
+                var pair = pairs[i];
+                if (!pair) {
+                    continue;
+                }
+                var equalsIndex = strIndexOf(pair, "=");
+                if (equalsIndex === -1) {
+                    resultParts[_DYN_PUSH ](pair);
+                }
+                else {
+                    var paramName = pair[_DYN_SUBSTRING ](0, equalsIndex);
+                    var paramValue = pair[_DYN_SUBSTRING ](equalsIndex + 1);
+                    if (paramValue === STR_EMPTY) {
+                        resultParts[_DYN_PUSH ](pair);
+                    }
+                    else {
+                        var shouldRedact = false;
+                        for (var j = 0; j < sensitiveParams[_DYN_LENGTH$2 ]; j++) {
+                            if (paramName === sensitiveParams[j]) {
+                                shouldRedact = true;
+                                anyParamRedacted = true;
+                                break;
+                            }
+                        }
+                        if (shouldRedact) {
+                            resultParts[_DYN_PUSH ](paramName + "=" + STR_REDACTED);
+                        }
+                        else {
+                            resultParts[_DYN_PUSH ](pair);
+                        }
+                    }
+                }
+            }
+        }
+        if (!anyParamRedacted) {
+            return url;
+        }
+        return baseUrl + resultParts.join("&") + fragment;
+    }
+    function fieldRedaction(input, config) {
+        if (!input || input[_DYN_INDEX_OF ](" ") !== -1) {
+            return input;
+        }
+        var isRedactionDisabled = config && config.redactUrls === false;
+        if (isRedactionDisabled) {
+            return input;
+        }
+        var hasCredentials = strIndexOf(input, "@") !== -1;
+        var hasQueryParams = strIndexOf(input, "?") !== -1;
+        if (!hasCredentials && !hasQueryParams) {
+            return input;
+        }
+        try {
+            var result = input;
+            if (hasCredentials) {
+                result = redactUserInfo(input);
+            }
+            if (hasQueryParams) {
+                result = redactQueryParameters(result, config);
+            }
+            return result;
+        }
+        catch (e) {
+            return input;
+        }
+    }
 
     var UInt32Mask = 0x100000000;
     var MaxUInt32 = 0xffffffff;
@@ -1422,7 +1586,7 @@
         return result;
     }
 
-    var version = '3.4.0-nightlybeta3.2505-36';
+    var version = '3.4.0-nightlybeta3.2507-23';
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _canAcceptData(target) {
@@ -2088,6 +2252,307 @@
         return createDynamicConfig(config, null, logger)[_DYN_WATCH ](configHandler);
     }
 
+    function generateW3CId() {
+        var hexValues = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
+        var oct = STR_EMPTY, tmp;
+        for (var a = 0; a < 4; a++) {
+            tmp = random32();
+            oct +=
+                hexValues[tmp & 0xF] +
+                    hexValues[tmp >> 4 & 0xF] +
+                    hexValues[tmp >> 8 & 0xF] +
+                    hexValues[tmp >> 12 & 0xF] +
+                    hexValues[tmp >> 16 & 0xF] +
+                    hexValues[tmp >> 20 & 0xF] +
+                    hexValues[tmp >> 24 & 0xF] +
+                    hexValues[tmp >> 28 & 0xF];
+        }
+        var clockSequenceHi = hexValues[8 + (random32() & 0x03) | 0];
+        return strSubstr(oct, 0, 8) + strSubstr(oct, 9, 4) + "4" + strSubstr(oct, 13, 3) + clockSequenceHi + strSubstr(oct, 16, 3) + strSubstr(oct, 19, 12);
+    }
+
+    var DEFAULT_VERSION = "00";
+    var INVALID_VERSION = "ff";
+    var INVALID_TRACE_ID = "00000000000000000000000000000000";
+    var INVALID_SPAN_ID = "0000000000000000";
+    function _isValid(value, len, invalidValue) {
+        if (value && value[_DYN_LENGTH$2 ] === len && value !== invalidValue) {
+            return !!value.match(/^[\da-f]*$/i);
+        }
+        return false;
+    }
+    function _formatValue(value, len, defValue) {
+        if (_isValid(value, len)) {
+            return value;
+        }
+        return defValue;
+    }
+    function _formatFlags(value) {
+        if (isNaN(value) || value < 0 || value > 255) {
+            value = 0x01;
+        }
+        var result = value.toString(16);
+        while (result[_DYN_LENGTH$2 ] < 2) {
+            result = "0" + result;
+        }
+        return result;
+    }
+    function createTraceParent(traceId, spanId, flags, version) {
+        return {
+            version: _isValid(version, 2, INVALID_VERSION) ? version : DEFAULT_VERSION,
+            traceId: isValidTraceId(traceId) ? traceId : generateW3CId(),
+            spanId: isValidSpanId(spanId) ? spanId : strLeft(generateW3CId(), 16),
+            traceFlags: (!isNullOrUndefined(flags) && flags >= 0 && flags <= 0xFF ? flags : 1 )
+        };
+    }
+    function isValidTraceId(value) {
+        return _isValid(value, 32, INVALID_TRACE_ID);
+    }
+    function isValidSpanId(value) {
+        return _isValid(value, 16, INVALID_SPAN_ID);
+    }
+    function formatTraceParent(value) {
+        if (value) {
+            var flags = _formatFlags(value[_DYN_TRACE_FLAGS$2 ]);
+            if (!_isValid(flags, 2)) {
+                flags = "01";
+            }
+            var version = value[_DYN_VERSION ] || DEFAULT_VERSION;
+            if (version !== "00" && version !== "ff") {
+                version = DEFAULT_VERSION;
+            }
+            return "".concat(version.toLowerCase(), "-").concat(_formatValue(value.traceId, 32, INVALID_TRACE_ID).toLowerCase(), "-").concat(_formatValue(value.spanId, 16, INVALID_SPAN_ID).toLowerCase(), "-").concat(flags.toLowerCase());
+        }
+        return STR_EMPTY;
+    }
+
+    var MAX_TRACE_STATE_MEMBERS = 32;
+    var MAX_TRACE_STATE_LEN = 512;
+    var LCALPHA = "[a-z]";
+    var LCALPHA_DIGIT = "[a-z\\d]";
+    var LCALPHA_DIGIT_UNDERSCORE_DASH_STAR_SLASH = "[a-z\\d_\\-*\\/]";
+    var SIMPLE_KEY = "(" + LCALPHA + LCALPHA_DIGIT_UNDERSCORE_DASH_STAR_SLASH + "{0,255})";
+    var TENANT_ID = "(" + LCALPHA_DIGIT + LCALPHA_DIGIT_UNDERSCORE_DASH_STAR_SLASH + "{0,240})";
+    var SYSTEM_ID = "(" + LCALPHA + LCALPHA_DIGIT_UNDERSCORE_DASH_STAR_SLASH + "{0,13})";
+    var MULTI_TENANT_KEY = "(" + TENANT_ID + "@" + SYSTEM_ID + ")";
+    var NBLK_CHAR = "\x21-\x2B\\--\x3C\x3E-\x7E";
+    var TRACESTATE_VALUE = "[\x20" + NBLK_CHAR + "]{0,255}[" + NBLK_CHAR + "]";
+    var TRACESTATE_KVP_REGEX = new RegExp("^\\s*((?:" + SIMPLE_KEY + "|" + MULTI_TENANT_KEY + ")=(" + TRACESTATE_VALUE + "))\\s*$");
+    function _parseListMember(value) {
+        if (value) {
+            TRACESTATE_KVP_REGEX.lastIndex = 0;
+            var match = TRACESTATE_KVP_REGEX.exec(value);
+            if (match && match[_DYN_LENGTH$2 ] >= 7 && match[1] && match[6]) {
+                var type = match[3] ? 1  : 0 ;
+                var multiTenant = null;
+                if (type === 1 ) {
+                    multiTenant = {
+                        tenantId: match[4],
+                        systemId: match[5]
+                    };
+                }
+                var parts = {
+                    type: type,
+                    key: match[2],
+                    multiTenant: multiTenant,
+                    value: match[6]
+                };
+                return parts;
+            }
+        }
+        return null;
+    }
+    function _parseTraceStateList(value) {
+        var items = [];
+        if (value) {
+            var addedKeys_1 = [];
+            arrForEach(strSplit(value, ","), function (member) {
+                var parts = _parseListMember(member);
+                if (parts) {
+                    if (arrIndexOf(addedKeys_1, parts.key) === -1) {
+                        items[_DYN_PUSH ](parts);
+                        addedKeys_1[_DYN_PUSH ](parts.key);
+                        if (items[_DYN_LENGTH$2 ] >= MAX_TRACE_STATE_MEMBERS) {
+                            return -1;
+                        }
+                    }
+                }
+            });
+        }
+        return items;
+    }
+    function _indexOf$1(items, key) {
+        for (var lp = 0; lp < items[_DYN_LENGTH$2 ]; lp++) {
+            if (items[lp].key === key) {
+                return lp;
+            }
+        }
+        return -1;
+    }
+    function _keys(items, parent) {
+        var keys = [];
+        var delKeys = [];
+        arrForEach(items, function (member) {
+            if (member[_DYN_VALUE ] != null) {
+                keys[_DYN_PUSH ](member.key);
+            }
+            else {
+                delKeys[_DYN_PUSH ](member.key);
+            }
+        });
+        if (parent) {
+            arrForEach(parent.keys, function (key) {
+                if (arrIndexOf(keys, key) === -1 && arrIndexOf(delKeys, key) === -1) {
+                    keys[_DYN_PUSH ](key);
+                }
+            });
+        }
+        return keys;
+    }
+    function _isEmpty(items, parent) {
+        var delKeys;
+        var isEmpty = true;
+        if (items && items[_DYN_LENGTH$2 ] > 0) {
+            arrForEach(items, function (member) {
+                if (member[_DYN_VALUE ] != null) {
+                    isEmpty = false;
+                }
+                else {
+                    if (!delKeys) {
+                        delKeys = [];
+                    }
+                    delKeys[_DYN_PUSH ](member.key);
+                }
+            });
+        }
+        if (isEmpty && parent) {
+            isEmpty = parent.isEmpty;
+            if (!isEmpty && delKeys && delKeys[_DYN_LENGTH$2 ] > 0) {
+                isEmpty = true;
+                arrForEach(parent.keys, function (key) {
+                    if (arrIndexOf(delKeys, key) === -1) {
+                        isEmpty = false;
+                        return -1;
+                    }
+                });
+            }
+        }
+        return isEmpty;
+    }
+    function createW3cTraceState(value, parent) {
+        var cachedItems = createDeferredCachedValue(function () { return safe(_parseTraceStateList, [value || STR_EMPTY]).v || []; });
+        function _get(key) {
+            var value;
+            var theItems = cachedItems.v;
+            var idx = _indexOf$1(theItems, key);
+            if (idx !== -1) {
+                var itmValue = theItems[idx][_DYN_VALUE ];
+                if (itmValue != null) {
+                    value = itmValue;
+                }
+            }
+            else if (parent) {
+                value = parent.get(key);
+            }
+            return value;
+        }
+        function _setMember(member) {
+            if (member) {
+                var theItems = cachedItems.v;
+                var idx = _indexOf$1(theItems, member.key);
+                if (idx !== -1) {
+                    theItems[_DYN_SPLICE ](idx, 1);
+                }
+                theItems.unshift(member);
+                cachedItems = createCachedValue(theItems);
+                return 0;
+            }
+            return -1;
+        }
+        function _set(key, value) {
+            var member;
+            if (key && isString(key) && !isNullOrUndefined(value) && isString(value)) {
+                member = _parseListMember(key + "=" + value);
+            }
+            return _setMember(member);
+        }
+        function _del(key) {
+            _setMember({
+                type: 2 ,
+                key: key
+            });
+        }
+        function _headers(maxHeaders, maxKeys, maxLen) {
+            var results = [];
+            var result = STR_EMPTY;
+            var numKeys = 0;
+            var len = 0;
+            maxKeys = maxKeys || MAX_TRACE_STATE_MEMBERS;
+            maxLen = maxLen || MAX_TRACE_STATE_LEN;
+            var theItems = cachedItems.v;
+            arrForEach(_keys(theItems, parent), function (key) {
+                var value = _get(key);
+                if (!isNullOrUndefined(value) && isString(value)) {
+                    numKeys++;
+                    var val = key + "=" + value;
+                    var valLen = val[_DYN_LENGTH$2 ];
+                    if (len + 1 + valLen >= maxLen) {
+                        results[_DYN_PUSH ](result);
+                        if (maxHeaders && results[_DYN_LENGTH$2 ] <= maxHeaders) {
+                            return -1;
+                        }
+                        result = STR_EMPTY;
+                        len = 0;
+                    }
+                    if (result[_DYN_LENGTH$2 ] > 0) {
+                        result += ",";
+                        len++;
+                    }
+                    result += val;
+                    len += valLen;
+                    if (numKeys >= maxKeys) {
+                        return -1;
+                    }
+                }
+            });
+            if (result) {
+                results[_DYN_PUSH ](result);
+            }
+            return results;
+        }
+        var traceStateList = {
+            keys: [],
+            isEmpty: false,
+            get: _get,
+            set: _set,
+            del: _del,
+            hdrs: _headers,
+            child: function () { return createW3cTraceState(null, traceStateList); }
+        };
+        function _toString() {
+            var headers = traceStateList.hdrs(1);
+            return headers[_DYN_LENGTH$2 ] > 0 ? headers[0] : STR_EMPTY;
+        }
+        objDefineProps(traceStateList, {
+            "keys": {
+                g: function () { return _keys(cachedItems.v, parent); }
+            },
+            "isEmpty": {
+                g: function () { return _isEmpty(cachedItems.v, parent); }
+            },
+            "toString": {
+                v: _toString,
+                e: false
+            },
+            "_p": {
+                v: parent,
+                e: false
+            }
+        });
+        objDefine(traceStateList, getKnownSymbol(11 ), { g: _toString });
+        return traceStateList;
+    }
+
     var _aiNamespace = null;
     function _getExtensionNamespace() {
         var target = getInst("Microsoft");
@@ -2398,83 +2863,151 @@
         return func();
     }
 
-    function generateW3CId() {
-        var hexValues = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
-        var oct = STR_EMPTY, tmp;
-        for (var a = 0; a < 4; a++) {
-            tmp = random32();
-            oct +=
-                hexValues[tmp & 0xF] +
-                    hexValues[tmp >> 4 & 0xF] +
-                    hexValues[tmp >> 8 & 0xF] +
-                    hexValues[tmp >> 12 & 0xF] +
-                    hexValues[tmp >> 16 & 0xF] +
-                    hexValues[tmp >> 20 & 0xF] +
-                    hexValues[tmp >> 24 & 0xF] +
-                    hexValues[tmp >> 28 & 0xF];
-        }
-        var clockSequenceHi = hexValues[8 + (random32() & 0x03) | 0];
-        return strSubstr(oct, 0, 8) + strSubstr(oct, 9, 4) + "4" + strSubstr(oct, 13, 3) + clockSequenceHi + strSubstr(oct, 16, 3) + strSubstr(oct, 19, 12);
+    var pluginStateData = createElmNodeData("plugin");
+    function _getPluginState(plugin) {
+        return pluginStateData.get(plugin, "state", {}, true);
     }
-
-    var DEFAULT_VERSION = "00";
-    var INVALID_VERSION = "ff";
-    var INVALID_TRACE_ID = "00000000000000000000000000000000";
-    var INVALID_SPAN_ID = "0000000000000000";
-    function _isValid(value, len, invalidValue) {
-        if (value && value[_DYN_LENGTH$2 ] === len && value !== invalidValue) {
-            return !!value.match(/^[\da-f]*$/i);
+    function isDistributedTraceContext(obj) {
+        return obj &&
+            isFunction(obj.getName) &&
+            isFunction(obj.getTraceId) &&
+            isFunction(obj.getSpanId) &&
+            isFunction(obj.getTraceFlags) &&
+            isFunction(obj.setName) &&
+            isFunction(obj.setTraceId) &&
+            isFunction(obj.setSpanId) &&
+            isFunction(obj[_DYN_SET_TRACE_FLAGS ]);
+    }
+    function createDistributedTraceContext(parent) {
+        var _a;
+        var parentCtx = null;
+        var spanContext = null;
+        var traceId = (parent && isValidTraceId(parent[_DYN_TRACE_ID$1 ])) ? parent[_DYN_TRACE_ID$1 ] : generateW3CId();
+        var spanId = (parent && isValidSpanId(parent[_DYN_SPAN_ID$1 ])) ? parent[_DYN_SPAN_ID$1 ] : STR_EMPTY;
+        var traceFlags = parent ? parent[_DYN_TRACE_FLAGS$2 ] : UNDEFINED_VALUE;
+        var isRemote = parent ? parent.isRemote : false;
+        var pageName = STR_EMPTY;
+        var traceState = null;
+        if (parent) {
+            if (isDistributedTraceContext(parent)) {
+                parentCtx = parent;
+                pageName = parentCtx.getName();
+            }
+            else {
+                spanContext = parent;
+            }
         }
-        return false;
-    }
-    function _formatValue(value, len, defValue) {
-        if (_isValid(value, len)) {
-            return value;
+        if (!pageName) {
+            pageName = "_unknown_";
+            var location_1 = getLocation();
+            if (location_1 && location_1.pathname) {
+                pageName = location_1.pathname + (location_1.hash || "");
+            }
         }
-        return defValue;
-    }
-    function _formatFlags(value) {
-        if (isNaN(value) || value < 0 || value > 255) {
-            value = 0x01;
+        function _getName() {
+            return pageName;
         }
-        var result = value.toString(16);
-        while (result[_DYN_LENGTH$2 ] < 2) {
-            result = "0" + result;
+        function _setPageNameFn(updateParent) {
+            return function (newValue) {
+                if (updateParent) {
+                    parentCtx && parentCtx.setName(newValue);
+                }
+                pageName = newValue;
+            };
         }
-        return result;
-    }
-    function createTraceParent(traceId, spanId, flags, version) {
-        return {
-            version: _isValid(version, 2, INVALID_VERSION) ? version : DEFAULT_VERSION,
-            traceId: isValidTraceId(traceId) ? traceId : generateW3CId(),
-            spanId: isValidSpanId(spanId) ? spanId : strLeft(generateW3CId(), 16),
-            traceFlags: flags >= 0 && flags <= 0xFF ? flags : 1
-        };
-    }
-    function isValidTraceId(value) {
-        return _isValid(value, 32, INVALID_TRACE_ID);
-    }
-    function isValidSpanId(value) {
-        return _isValid(value, 16, INVALID_SPAN_ID);
-    }
-    function formatTraceParent(value) {
-        if (value) {
-            var flags = _formatFlags(value[_DYN_TRACE_FLAGS$1 ]);
-            if (!_isValid(flags, 2)) {
-                flags = "01";
-            }
-            var version = value[_DYN_VERSION ] || DEFAULT_VERSION;
-            if (version !== "00" && version !== "ff") {
-                version = DEFAULT_VERSION;
+        function _getTraceId() {
+            return traceId;
+        }
+        function _setTraceIdFn(updateParent) {
+            return function (newValue) {
+                if (updateParent) {
+                    parentCtx && parentCtx.setTraceId(newValue);
+                }
+                if (isValidTraceId(newValue)) {
+                    traceId = newValue;
+                }
+            };
+        }
+        function _getSpanId() {
+            return spanId;
+        }
+        function _setSpanIdFn(updateParent) {
+            return function (newValue) {
+                if (updateParent) {
+                    parentCtx && parentCtx.setSpanId(newValue);
+                }
+                if (isValidSpanId(newValue)) {
+                    spanId = newValue;
+                }
+            };
+        }
+        function _getTraceFlags() {
+            return traceFlags;
+        }
+        function _setTraceFlagsFn(updateParent) {
+            return function (newTraceFlags) {
+                if (updateParent) {
+                    parentCtx && parentCtx[_DYN_SET_TRACE_FLAGS ](newTraceFlags);
+                }
+                traceFlags = newTraceFlags;
+            };
+        }
+        function _getTraceState() {
+            if (!traceState) {
+                if (spanContext && spanContext[_DYN_TRACE_STATE$1 ]) {
+                    traceState = createW3cTraceState(spanContext[_DYN_TRACE_STATE$1 ].serialize() || STR_EMPTY, parentCtx ? parentCtx[_DYN_TRACE_STATE$1 ] : undefined);
+                }
+                else {
+                    traceState = createW3cTraceState(STR_EMPTY, parentCtx ? parentCtx[_DYN_TRACE_STATE$1 ] : undefined);
+                }
             }
-            return "".concat(version.toLowerCase(), "-").concat(_formatValue(value.traceId, 32, INVALID_TRACE_ID).toLowerCase(), "-").concat(_formatValue(value.spanId, 16, INVALID_SPAN_ID).toLowerCase(), "-").concat(flags.toLowerCase());
+            return traceState;
         }
-        return "";
-    }
-
-    var pluginStateData = createElmNodeData("plugin");
-    function _getPluginState(plugin) {
-        return pluginStateData.get(plugin, "state", {}, true);
+        var traceCtx = (_a = {
+                getName: _getName,
+                setName: _setPageNameFn(true),
+                getTraceId: _getTraceId,
+                setTraceId: _setTraceIdFn(true),
+                getSpanId: _getSpanId,
+                setSpanId: _setSpanIdFn(true),
+                getTraceFlags: _getTraceFlags
+            },
+            _a[_DYN_SET_TRACE_FLAGS ] = _setTraceFlagsFn(true),
+            _a.traceId = traceId,
+            _a.spanId = spanId,
+            _a.traceFlags = traceFlags,
+            _a.traceState = traceState,
+            _a.isRemote = isRemote,
+            _a.pageName = pageName,
+            _a);
+        return objDefineProps(traceCtx, {
+            pageName: {
+                g: _getName,
+                s: _setPageNameFn(false)
+            },
+            traceId: {
+                g: _getTraceId,
+                s: _setTraceIdFn(false)
+            },
+            spanId: {
+                g: _getSpanId,
+                s: _setSpanIdFn(false)
+            },
+            traceFlags: {
+                g: _getTraceFlags,
+                s: _setTraceFlagsFn(false)
+            },
+            isRemote: {
+                v: isRemote,
+                w: false
+            },
+            traceState: {
+                g: _getTraceState
+            },
+            parentCtx: {
+                g: function () { return parentCtx; }
+            }
+        });
     }
 
     var strTelemetryPluginChain = "TelemetryPluginChain";
@@ -2560,27 +3093,26 @@
         }
         function _getExtCfg(identifier, createIfMissing) {
             var idCfg = null;
-            var cfg = dynamicHandler.cfg;
+            var extCfg = _getCfg(dynamicHandler.cfg, "extensionConfig", createIfMissing);
+            if (extCfg) {
+                idCfg = _getCfg(extCfg, identifier, createIfMissing);
+            }
+            return idCfg;
+        }
+        function _getCfg(cfg, identifier, createIfMissing) {
+            var idCfg = null;
             if (cfg && identifier) {
-                var extCfg = cfg[STR_EXTENSION_CONFIG ];
-                if (!extCfg && createIfMissing) {
-                    extCfg = {};
-                }
-                cfg[STR_EXTENSION_CONFIG] = extCfg;
-                extCfg = dynamicHandler.ref(cfg, STR_EXTENSION_CONFIG);
-                if (extCfg) {
-                    idCfg = extCfg[identifier];
-                    if (!idCfg && createIfMissing) {
-                        idCfg = {};
-                    }
-                    extCfg[identifier] = idCfg;
-                    idCfg = dynamicHandler.ref(extCfg, identifier);
+                idCfg = cfg[identifier];
+                if (!idCfg && createIfMissing) {
+                    idCfg = {};
                 }
+                cfg[identifier] = idCfg;
+                idCfg = dynamicHandler.ref(cfg, identifier);
             }
             return idCfg;
         }
-        function _resolveExtCfg(identifier, defaultValues) {
-            var newConfig = _getExtCfg(identifier, true);
+        function _resolveExtCfg(identifier, defaultValues, rootOnly) {
+            var newConfig = rootOnly ? _getCfg(dynamicHandler.cfg, identifier, true) : _getExtCfg(identifier, true);
             if (defaultValues) {
                 objForEachKey(defaultValues, function (field, defaultValue) {
                     if (isNullOrUndefined(newConfig[field])) {
@@ -3289,7 +3821,7 @@
     var strNotSpecified = "not_specified";
     var strIkey = "iKey";
 
-    var RequestHeaders = createValueMap({
+    var RequestHeaders = ( /* @__PURE__ */createValueMap({
         requestContextHeader: [0 , "Request-Context"],
         requestContextTargetKey: [1 , "appId"],
         requestContextAppIdFormat: [2 , "appId=cid-v1:"],
@@ -3299,7 +3831,7 @@
         sdkContextHeader: [6 , "Sdk-Context"],
         sdkContextHeaderAppIdRequest: [7 , "appId"],
         requestContextHeaderLowerCase: [8 , "request-context"]
-    });
+    }));
 
     var _DYN_SPLIT = "split";
     var _DYN_LENGTH$1 = "length";
@@ -3309,6 +3841,7 @@
     var _DYN_MATCH = "match";
     var _DYN_CORRELATION_HEADER_E0 = "correlationHeaderExcludePatterns";
     var _DYN_NAME = "name";
+    var _DYN_TRACE_FLAGS$1 = "traceFlags";
     var _DYN_PROPERTIES = "properties";
     var _DYN_MEASUREMENTS = "measurements";
     var _DYN_DURATION = "duration";
@@ -3351,7 +3884,10 @@
         }
         return valueTrunc || value;
     }
-    function dataSanitizeUrl(logger, url) {
+    function dataSanitizeUrl(logger, url, config) {
+        if (isString(url)) {
+            url = fieldRedaction(url, config);
+        }
         return dataSanitizeInput(logger, url, 2048 , 66 );
     }
     function dataSanitizeProperties(logger, properties) {
@@ -3584,41 +4120,14 @@
         return result;
     }
     function createDistributedTraceContextFromTrace(telemetryTrace, parentCtx) {
-        var trace = telemetryTrace || {};
-        return {
-            getName: function () {
-                return trace[_DYN_NAME ];
-            },
-            setName: function (newValue) {
-                parentCtx && parentCtx.setName(newValue);
-                trace[_DYN_NAME ] = newValue;
-            },
-            getTraceId: function () {
-                return trace.traceID;
-            },
-            setTraceId: function (newValue) {
-                parentCtx && parentCtx.setTraceId(newValue);
-                if (isValidTraceId(newValue)) {
-                    trace.traceID = newValue;
-                }
-            },
-            getSpanId: function () {
-                return trace.parentID;
-            },
-            setSpanId: function (newValue) {
-                parentCtx && parentCtx.setSpanId(newValue);
-                if (isValidSpanId(newValue)) {
-                    trace.parentID = newValue;
-                }
-            },
-            getTraceFlags: function () {
-                return trace.traceFlags;
-            },
-            setTraceFlags: function (newTraceFlags) {
-                parentCtx && parentCtx.setTraceFlags(newTraceFlags);
-                trace.traceFlags = newTraceFlags;
-            }
-        };
+        var traceCtx = createDistributedTraceContext(parentCtx);
+        if (telemetryTrace) {
+            traceCtx.pageName = telemetryTrace[_DYN_NAME ] || traceCtx.pageName || "";
+            traceCtx.traceId = telemetryTrace.traceID || traceCtx.traceId || "";
+            traceCtx.spanId = telemetryTrace.parentID || traceCtx.spanId || "";
+            traceCtx[_DYN_TRACE_FLAGS$1 ] = (!isNullOrUndefined(telemetryTrace[_DYN_TRACE_FLAGS$1 ]) ? telemetryTrace[_DYN_TRACE_FLAGS$1 ] : traceCtx[_DYN_TRACE_FLAGS$1 ]) || 0;
+        }
+        return traceCtx;
     }
 
     var strEmpty = "";
@@ -3816,11 +4325,12 @@
 
     var _DYN_REQUEST_URL = "requestUrl";
     var _DYN_LENGTH = "length";
-    var _DYN_TRACE_ID = "traceID";
-    var _DYN_SPAN_ID = "spanID";
+    var _DYN_ABORTED = "aborted";
+    var _DYN_TRACE_ID = "traceId";
+    var _DYN_SPAN_ID = "spanId";
     var _DYN_TRACE_FLAGS = "traceFlags";
+    var _DYN_TRACE_STATE = "traceState";
     var _DYN_CONTEXT = "context";
-    var _DYN_ABORTED = "aborted";
     var _DYN__ADD_HOOK = "_addHook";
     var _DYN_CORE = "core";
     var _DYN_INCLUDE_CORRELATION_0 = "includeCorrelationHeaders";
@@ -3844,8 +4354,6 @@
     var _DYN_STATUS_TEXT = "statusText";
     var _DYN_HEADER_MAP = "headerMap";
     var _DYN_REQUEST_SENT_TIME = "requestSentTime";
-    var _DYN_GET_TRACE_ID = "getTraceId";
-    var _DYN_GET_TRACE_FLAGS = "getTraceFlags";
     var _DYN_METHOD = "method";
     var _DYN_ERROR_STATUS_TEXT = "errorStatusText";
     var _DYN_STATE_CHANGE_ATTACHE11 = "stateChangeAttached";
@@ -3853,13 +4361,10 @@
     var _DYN_RESPONSE_FINISHED_TI12 = "responseFinishedTime";
     var _DYN__CREATE_TRACK_ITEM = "CreateTrackItem";
     var _DYN_GET_ALL_RESPONSE_HEA13 = "getAllResponseHeaders";
-    var _DYN_GET_PART_APROPS = "getPartAProps";
-    var _DYN_PERF_MARK = "perfMark";
     var _DYN_PERF_TIMING = "perfTiming";
     var _DYN_AJAX_DIAGNOSTICS_MES14 = "ajaxDiagnosticsMessage";
     var _DYN_CORRELATION_CONTEXT = "correlationContext";
     var _DYN_AJAX_TOTAL_DURATION = "ajaxTotalDuration";
-    var _DYN_EVENT_TRACE_CTX = "eventTraceCtx";
 
     function _calcPerfDuration(resourceEntry, start, end) {
         var result = 0;
@@ -3954,7 +4459,7 @@
             propsSet |= _setPerfValue(props, strDecodedBodySize, resourceEntry[strDecodedBodySize]);
         }
         else {
-            if (ajaxData[_DYN_PERF_MARK ]) {
+            if (ajaxData.perfMark) {
                 propsSet |= _setPerfValue(props, "missing", ajaxData.perfAttempts);
             }
         }
@@ -3962,144 +4467,130 @@
             dependency[STR_PROPERTIES ] = props;
         }
     }
-    var XHRMonitoringState = /** @class */ (function () {
-        function XHRMonitoringState() {
-            var self = this;
-            self.openDone = false;
-            self.setRequestHeaderDone = false;
-            self.sendDone = false;
-            self.abortDone = false;
-            self[_DYN_STATE_CHANGE_ATTACHE11 ] = false;
-        }
-        return XHRMonitoringState;
-    }());
-    var ajaxRecord = /** @class */ (function () {
-        function ajaxRecord(traceId, spanId, logger, traceCtx) {
-            var self = this;
-            var _logger = logger;
-            var strResponseText = "responseText";
-            self[_DYN_PERF_MARK ] = null;
-            self.completed = false;
-            self.requestHeadersSize = null;
-            self[_DYN_REQUEST_HEADERS ] = null;
-            self.responseReceivingDuration = null;
-            self.callbackDuration = null;
-            self[_DYN_AJAX_TOTAL_DURATION ] = null;
-            self[_DYN_ABORTED ] = 0;
-            self.pageUrl = null;
-            self[_DYN_REQUEST_URL ] = null;
-            self.requestSize = 0;
-            self[_DYN_METHOD ] = null;
-            self[_DYN_STATUS ] = null;
-            self[_DYN_REQUEST_SENT_TIME ] = null;
-            self.responseStartedTime = null;
-            self[_DYN_RESPONSE_FINISHED_TI12 ] = null;
-            self.callbackFinishedTime = null;
-            self.endTime = null;
-            self.xhrMonitoringState = new XHRMonitoringState();
-            self.clientFailure = 0;
-            self[_DYN_TRACE_ID ] = traceId;
-            self[_DYN_SPAN_ID ] = spanId;
-            self[_DYN_TRACE_FLAGS ] = traceCtx === null || traceCtx === void 0 ? void 0 : traceCtx.getTraceFlags();
-            if (traceCtx) {
-                self[_DYN_EVENT_TRACE_CTX ] = {
-                    traceId: traceCtx[_DYN_GET_TRACE_ID ](),
-                    spanId: traceCtx.getSpanId(),
-                    traceFlags: traceCtx[_DYN_GET_TRACE_FLAGS ]()
-                };
-            }
-            else {
-                self[_DYN_EVENT_TRACE_CTX ] = null;
-            }
-            dynamicProto(ajaxRecord, self, function (self) {
-                self.getAbsoluteUrl = function () {
-                    return self[_DYN_REQUEST_URL ] ? urlGetAbsoluteUrl(self[_DYN_REQUEST_URL ]) : null;
-                };
-                self.getPathName = function () {
-                    return self[_DYN_REQUEST_URL ] ? dataSanitizeUrl(_logger, urlGetCompleteUrl(self[_DYN_METHOD ], self[_DYN_REQUEST_URL ])) : null;
-                };
-                self[_DYN__CREATE_TRACK_ITEM ] = function (ajaxType, enableRequestHeaderTracking, getResponse) {
-                    var _a;
-                    self.ajaxTotalDuration = mathRound(dateTimeUtilsDuration(self.requestSentTime, self.responseFinishedTime) * 1000) / 1000;
-                    if (self[_DYN_AJAX_TOTAL_DURATION ] < 0) {
-                        return null;
-                    }
-                    var dependency = (_a = {
-                            id: "|" + self[_DYN_TRACE_ID ] + "." + self[_DYN_SPAN_ID ],
-                            target: self[_DYN_GET_ABSOLUTE_URL ](),
-                            name: self.getPathName(),
-                            type: ajaxType,
-                            startTime: null,
-                            duration: self[_DYN_AJAX_TOTAL_DURATION ],
-                            success: (+(self[_DYN_STATUS ])) >= 200 && (+(self[_DYN_STATUS ])) < 400,
-                            responseCode: (+(self[_DYN_STATUS ]))
-                        },
-                        _a[STR_PROPERTIES] = { HttpMethod: self[_DYN_METHOD ] },
-                        _a);
-                    var props = dependency[STR_PROPERTIES];
-                    if (self[_DYN_ABORTED ]) {
-                        props[_DYN_ABORTED ] = true;
-                    }
-                    if (self[_DYN_REQUEST_SENT_TIME ]) {
-                        dependency[_DYN_START_TIME ] = new Date();
-                        dependency[_DYN_START_TIME ].setTime(self[_DYN_REQUEST_SENT_TIME ]);
-                    }
-                    _populatePerfData(self, dependency);
-                    if (enableRequestHeaderTracking) {
-                        if (objKeys(self.requestHeaders)[_DYN_LENGTH ] > 0) {
-                            props[_DYN_REQUEST_HEADERS ] = self[_DYN_REQUEST_HEADERS ];
-                        }
+    function createXHRMonitoringState() {
+        var _a;
+        return _a = {
+                openDone: false,
+                setRequestHeaderDone: false,
+                sendDone: false,
+                abortDone: false
+            },
+            _a[_DYN_STATE_CHANGE_ATTACHE11 ] = false,
+            _a;
+    }
+    function createAjaxRecord(traceCtx, logger) {
+        var _a;
+        var _logger = logger;
+        var ajaxRecord = (_a = {
+                perfMark: null,
+                completed: false,
+                requestHeadersSize: null
+            },
+            _a[_DYN_REQUEST_HEADERS ] = null,
+            _a.responseReceivingDuration = null,
+            _a.callbackDuration = null,
+            _a[_DYN_AJAX_TOTAL_DURATION ] = null,
+            _a.aborted = 0,
+            _a.pageUrl = null,
+            _a.requestUrl = null,
+            _a.requestSize = 0,
+            _a.method = null,
+            _a.status = null,
+            _a[_DYN_REQUEST_SENT_TIME ] = null,
+            _a.responseStartedTime = null,
+            _a[_DYN_RESPONSE_FINISHED_TI12 ] = null,
+            _a.callbackFinishedTime = null,
+            _a.endTime = null,
+            _a.xhrMonitoringState = createXHRMonitoringState(),
+            _a.clientFailure = 0,
+            _a.traceCtx = traceCtx,
+            _a.perfTiming = null,
+            _a[_DYN_GET_ABSOLUTE_URL ] = function () {
+                return ajaxRecord[_DYN_REQUEST_URL ] ? urlGetAbsoluteUrl(ajaxRecord[_DYN_REQUEST_URL ]) : null;
+            },
+            _a.getPathName = function () {
+                return ajaxRecord[_DYN_REQUEST_URL ] ? dataSanitizeUrl(_logger, urlGetCompleteUrl(ajaxRecord[_DYN_METHOD ], ajaxRecord[_DYN_REQUEST_URL ])) : null;
+            },
+            _a[_DYN__CREATE_TRACK_ITEM ] = function (ajaxType, enableRequestHeaderTracking, getResponse) {
+                var _a;
+                ajaxRecord.ajaxTotalDuration = mathRound(dateTimeUtilsDuration(ajaxRecord.requestSentTime, ajaxRecord.responseFinishedTime) * 1000) / 1000;
+                if (ajaxRecord[_DYN_AJAX_TOTAL_DURATION ] < 0) {
+                    return null;
+                }
+                var dependency = (_a = {
+                        id: "|" + traceCtx[_DYN_TRACE_ID ] + "." + traceCtx[_DYN_SPAN_ID ],
+                        target: ajaxRecord[_DYN_GET_ABSOLUTE_URL ](),
+                        name: ajaxRecord.getPathName(),
+                        type: ajaxType,
+                        startTime: null,
+                        duration: ajaxRecord[_DYN_AJAX_TOTAL_DURATION ],
+                        success: (+(ajaxRecord[_DYN_STATUS ])) >= 200 && (+(ajaxRecord[_DYN_STATUS ])) < 400,
+                        responseCode: (+(ajaxRecord[_DYN_STATUS ]))
+                    },
+                    _a[STR_PROPERTIES] = { HttpMethod: ajaxRecord[_DYN_METHOD ] },
+                    _a);
+                var props = dependency[STR_PROPERTIES];
+                if (ajaxRecord[_DYN_ABORTED ]) {
+                    props[_DYN_ABORTED ] = true;
+                }
+                if (ajaxRecord[_DYN_REQUEST_SENT_TIME ]) {
+                    dependency[_DYN_START_TIME ] = new Date();
+                    dependency[_DYN_START_TIME ].setTime(ajaxRecord[_DYN_REQUEST_SENT_TIME ]);
+                }
+                _populatePerfData(this, dependency);
+                if (enableRequestHeaderTracking) {
+                    if (objKeys(ajaxRecord.requestHeaders)[_DYN_LENGTH ] > 0) {
+                        props[_DYN_REQUEST_HEADERS ] = ajaxRecord[_DYN_REQUEST_HEADERS ];
                     }
-                    if (getResponse) {
-                        var response = getResponse();
-                        if (response) {
-                            var correlationContext = response[_DYN_CORRELATION_CONTEXT ];
-                            if (correlationContext) {
-                                dependency.correlationContext =  correlationContext;
-                            }
-                            if (response[_DYN_HEADER_MAP ]) {
-                                if (objKeys(response.headerMap)[_DYN_LENGTH ] > 0) {
-                                    props.responseHeaders = response[_DYN_HEADER_MAP ];
-                                }
+                }
+                if (getResponse) {
+                    var response = getResponse();
+                    if (response) {
+                        var correlationContext = response[_DYN_CORRELATION_CONTEXT ];
+                        if (correlationContext) {
+                            dependency.correlationContext =  correlationContext;
+                        }
+                        if (response[_DYN_HEADER_MAP ]) {
+                            if (objKeys(response.headerMap)[_DYN_LENGTH ] > 0) {
+                                props.responseHeaders = response[_DYN_HEADER_MAP ];
                             }
-                            if (self[_DYN_ERROR_STATUS_TEXT ]) {
-                                if (self[_DYN_STATUS ] >= 400) {
-                                    var responseType = response.type;
-                                    if (responseType === "" || responseType === "text") {
-                                        props.responseText = response.responseText ? response[_DYN_STATUS_TEXT ] + " - " + response[strResponseText] : response[_DYN_STATUS_TEXT ];
-                                    }
-                                    if (responseType === "json") {
-                                        props.responseText = response.response ? response[_DYN_STATUS_TEXT ] + " - " + JSON.stringify(response.response) : response[_DYN_STATUS_TEXT ];
-                                    }
+                        }
+                        if (ajaxRecord[_DYN_ERROR_STATUS_TEXT ]) {
+                            if ((+(ajaxRecord[_DYN_STATUS ])) >= 400) {
+                                var responseType = response.type;
+                                if (responseType === "" || responseType === "text") {
+                                    props.responseText = response.responseText ? response[_DYN_STATUS_TEXT ] + " - " + response[_DYN_RESPONSE_TEXT ] : response[_DYN_STATUS_TEXT ];
                                 }
-                                else if (self[_DYN_STATUS ] === 0) {
-                                    props.responseText = response[_DYN_STATUS_TEXT ] || "";
+                                if (responseType === "json") {
+                                    props.responseText = response.response ? response[_DYN_STATUS_TEXT ] + " - " + JSON.stringify(response.response) : response[_DYN_STATUS_TEXT ];
                                 }
                             }
+                            else if (ajaxRecord[_DYN_STATUS ] === 0) {
+                                props.responseText = response[_DYN_STATUS_TEXT ] || "";
+                            }
                         }
                     }
-                    return dependency;
-                };
-                self[_DYN_GET_PART_APROPS ] = function () {
-                    var partA = null;
-                    var traceCtx = self[_DYN_EVENT_TRACE_CTX ];
-                    if (traceCtx && (traceCtx.traceId || traceCtx.spanId)) {
-                        partA = {};
-                        var traceExt = partA[Extensions.TraceExt] = {
-                            traceID: traceCtx.traceId,
-                            parentID: traceCtx.spanId
-                        };
-                        if (!isNullOrUndefined(traceCtx[_DYN_TRACE_FLAGS ])) {
-                            traceExt[_DYN_TRACE_FLAGS ] = traceCtx[_DYN_TRACE_FLAGS ];
-                        }
+                }
+                return dependency;
+            },
+            _a.getPartAProps = function () {
+                var partA = null;
+                var parentCtx = ajaxRecord.traceCtx.parentCtx;
+                if (parentCtx && (parentCtx[_DYN_TRACE_ID ] || parentCtx[_DYN_SPAN_ID ])) {
+                    partA = {};
+                    var traceExt = partA[Extensions.TraceExt] = {
+                        traceID: parentCtx[_DYN_TRACE_ID ],
+                        parentID: parentCtx[_DYN_SPAN_ID ]
+                    };
+                    if (!isNullOrUndefined(parentCtx[_DYN_TRACE_FLAGS ])) {
+                        traceExt[_DYN_TRACE_FLAGS ] = parentCtx[_DYN_TRACE_FLAGS ];
                     }
-                    return partA;
-                };
-            });
-        }
-        ajaxRecord.__ieDyn=1;
+                }
+                return partA;
+            },
+            _a);
         return ajaxRecord;
-    }());
+    }
 
     var _a;
     var strDiagLog = "diagLog";
@@ -4259,22 +4750,44 @@
         var initializersCount = listeners[_DYN_LENGTH ];
         var result = true;
         if (initializersCount > 0) {
+            var traceCtx_1 = ajaxData.traceCtx;
             var details = {
                 core: core,
                 xhr: xhr,
                 input: input,
                 init: init,
-                traceId: ajaxData[_DYN_TRACE_ID ],
-                spanId: ajaxData[_DYN_SPAN_ID ],
-                traceFlags: ajaxData[_DYN_TRACE_FLAGS ],
-                context: ajaxData[_DYN_CONTEXT ] || {},
                 aborted: !!ajaxData[_DYN_ABORTED ]
             };
+            objDefineProps(details, {
+                "traceId": {
+                    g: function () { return traceCtx_1[_DYN_TRACE_ID ]; },
+                    s: function (value) {
+                        traceCtx_1[_DYN_TRACE_ID ] = value;
+                    }
+                },
+                "spanId": {
+                    g: function () { return traceCtx_1[_DYN_SPAN_ID ]; },
+                    s: function (value) {
+                        traceCtx_1[_DYN_SPAN_ID ] = value;
+                    }
+                },
+                "traceFlags": {
+                    g: function () { return traceCtx_1[_DYN_TRACE_FLAGS ]; },
+                    s: function (value) {
+                        traceCtx_1[_DYN_TRACE_FLAGS ] = value;
+                    }
+                },
+                "traceState": {
+                    g: function () { return traceCtx_1[_DYN_TRACE_STATE ]; }
+                },
+                "context": {
+                    g: function () { return ajaxData[_DYN_CONTEXT ] || {}; },
+                    s: function (value) {
+                        ajaxData[_DYN_CONTEXT ] = value;
+                    }
+                }
+            });
             result = _processDependencyContainer(core, listeners, details, "listener");
-            ajaxData[_DYN_TRACE_ID ] = details.traceId;
-            ajaxData[_DYN_SPAN_ID ] = details.spanId;
-            ajaxData[_DYN_TRACE_FLAGS ] = details[_DYN_TRACE_FLAGS ];
-            ajaxData[_DYN_CONTEXT ] = details[_DYN_CONTEXT ];
         }
         return result;
     }
@@ -4330,6 +4843,7 @@
             var _context;
             var _isUsingW3CHeaders;
             var _isUsingAIHeaders;
+            var _isUsingW3CTraceState;
             var _markPrefix;
             var _enableAjaxPerfTracking;
             var _maxAjaxCallsPerView;
@@ -4377,41 +4891,65 @@
                                 if (!init) {
                                     init = {};
                                 }
-                                var headers = new Headers(init[_DYN_HEADERS ] || (input instanceof Request ? (input[_DYN_HEADERS ] || {}) : {}));
+                                var traceCtx = ajaxData.traceCtx;
+                                var headers_1 = new Headers(init[_DYN_HEADERS ] || (input instanceof Request ? (input[_DYN_HEADERS ] || {}) : {}));
                                 if (_isUsingAIHeaders) {
-                                    var id = "|" + ajaxData[_DYN_TRACE_ID ] + "." + ajaxData[_DYN_SPAN_ID ];
-                                    headers.set(RequestHeaders[3 ], id);
+                                    var id = "|" + traceCtx[_DYN_TRACE_ID ] + "." + traceCtx[_DYN_SPAN_ID ];
+                                    headers_1.set(RequestHeaders[3 ], id);
                                     if (_enableRequestHeaderTracking) {
                                         ajaxData[_DYN_REQUEST_HEADERS ][RequestHeaders[3 ]] = id;
                                     }
                                 }
                                 var appId = _appId || (_context && _context.appId());
                                 if (appId) {
-                                    headers.set(RequestHeaders[0 ], RequestHeaders[2 ] + appId);
+                                    headers_1.set(RequestHeaders[0 ], RequestHeaders[2 ] + appId);
                                     if (_enableRequestHeaderTracking) {
                                         ajaxData[_DYN_REQUEST_HEADERS ][RequestHeaders[0 ]] = RequestHeaders[2 ] + appId;
                                     }
                                 }
                                 if (_isUsingW3CHeaders) {
-                                    var traceFlags = ajaxData[_DYN_TRACE_FLAGS ];
+                                    var traceFlags = traceCtx[_DYN_TRACE_FLAGS ];
                                     if (isNullOrUndefined(traceFlags)) {
-                                        traceFlags = 0x01;
+                                        traceFlags = 1 ;
                                     }
-                                    var traceParent = formatTraceParent(createTraceParent(ajaxData[_DYN_TRACE_ID ], ajaxData[_DYN_SPAN_ID ], traceFlags));
-                                    headers.set(RequestHeaders[4 ], traceParent);
+                                    var traceParent = formatTraceParent(createTraceParent(traceCtx[_DYN_TRACE_ID ], traceCtx[_DYN_SPAN_ID ], traceFlags));
+                                    headers_1.set(RequestHeaders[4 ], traceParent);
                                     if (_enableRequestHeaderTracking) {
                                         ajaxData[_DYN_REQUEST_HEADERS ][RequestHeaders[4 ]] = traceParent;
                                     }
                                 }
-                                init[_DYN_HEADERS ] = headers;
+                                if (_isUsingW3CTraceState) {
+                                    if (traceCtx[_DYN_TRACE_STATE ] && !traceCtx[_DYN_TRACE_STATE ].isEmpty) {
+                                        var traceStateHeaders = traceCtx[_DYN_TRACE_STATE ].hdrs();
+                                        if (traceStateHeaders && traceStateHeaders[_DYN_LENGTH ] > 0) {
+                                            var stateSet_1 = false;
+                                            arrForEach(traceStateHeaders, function (stateValue) {
+                                                if (stateValue) {
+                                                    if (!stateSet_1) {
+                                                        stateSet_1 = true;
+                                                        headers_1.set(RequestHeaders[5 ], stateValue);
+                                                    }
+                                                    else {
+                                                        headers_1.append(RequestHeaders[5 ], stateValue);
+                                                    }
+                                                }
+                                            });
+                                        }
+                                        if (_enableRequestHeaderTracking) {
+                                            ajaxData[_DYN_REQUEST_HEADERS ][RequestHeaders[5 ]] = traceStateHeaders.join(",");
+                                        }
+                                    }
+                                }
+                                init[_DYN_HEADERS ] = headers_1;
                             }
                             return init;
                         }
                         else if (xhr) {
                             if (correlationIdCanIncludeCorrelationHeader(_extensionConfig, ajaxData[_DYN_GET_ABSOLUTE_URL ](), currentWindowHost)) {
+                                var traceCtx = ajaxData.traceCtx;
                                 if (_isUsingAIHeaders) {
                                     if (!_isHeaderSet(xhr, RequestHeaders[3 ])) {
-                                        var id = "|" + ajaxData[_DYN_TRACE_ID ] + "." + ajaxData[_DYN_SPAN_ID ];
+                                        var id = "|" + traceCtx[_DYN_TRACE_ID ] + "." + traceCtx[_DYN_SPAN_ID ];
                                         xhr[_DYN_SET_REQUEST_HEADER ](RequestHeaders[3 ], id);
                                         if (_enableRequestHeaderTracking) {
                                             ajaxData[_DYN_REQUEST_HEADERS ][RequestHeaders[3 ]] = id;
@@ -4434,12 +4972,12 @@
                                     }
                                 }
                                 if (_isUsingW3CHeaders) {
-                                    var traceFlags = ajaxData[_DYN_TRACE_FLAGS ];
+                                    var traceFlags = traceCtx[_DYN_TRACE_FLAGS ];
                                     if (isNullOrUndefined(traceFlags)) {
-                                        traceFlags = 0x01;
+                                        traceFlags = 1 ;
                                     }
                                     if (!_isHeaderSet(xhr, RequestHeaders[4 ])) {
-                                        var traceParent = formatTraceParent(createTraceParent(ajaxData[_DYN_TRACE_ID ], ajaxData[_DYN_SPAN_ID ], traceFlags));
+                                        var traceParent = formatTraceParent(createTraceParent(traceCtx[_DYN_TRACE_ID ], traceCtx[_DYN_SPAN_ID ], traceFlags));
                                         xhr[_DYN_SET_REQUEST_HEADER ](RequestHeaders[4 ], traceParent);
                                         if (_enableRequestHeaderTracking) {
                                             ajaxData[_DYN_REQUEST_HEADERS ][RequestHeaders[4 ]] = traceParent;
@@ -4449,6 +4987,21 @@
                                         _throwInternalWarning(_self, 71 , "Unable to set [" + RequestHeaders[4 ] + "] as it has already been set by another instance");
                                     }
                                 }
+                                if (_isUsingW3CTraceState) {
+                                    if (traceCtx[_DYN_TRACE_STATE ] && !traceCtx[_DYN_TRACE_STATE ].isEmpty) {
+                                        var traceStateHeaders = traceCtx[_DYN_TRACE_STATE ].hdrs();
+                                        if (traceStateHeaders && traceStateHeaders[_DYN_LENGTH ] > 0) {
+                                            arrForEach(traceStateHeaders, function (stateValue) {
+                                                if (stateValue) {
+                                                    xhr[_DYN_SET_REQUEST_HEADER ](RequestHeaders[5 ], stateValue);
+                                                }
+                                            });
+                                        }
+                                        if (_enableRequestHeaderTracking) {
+                                            ajaxData[_DYN_REQUEST_HEADERS ][RequestHeaders[5 ]] = traceStateHeaders.join(",");
+                                        }
+                                    }
+                                }
                             }
                             return xhr;
                         }
@@ -4491,6 +5044,7 @@
                     _trackAjaxAttempts = 0;
                     _context = null;
                     _isUsingW3CHeaders = false;
+                    _isUsingW3CTraceState = false;
                     _isUsingAIHeaders = false;
                     _markPrefix = null;
                     _enableAjaxPerfTracking = false;
@@ -4525,8 +5079,10 @@
                         _maxAjaxCallsPerView = _extensionConfig[_DYN_MAX_AJAX_CALLS_PER_V5 ];
                         _excludeRequestFromAutoTrackingPatterns = [].concat(_extensionConfig[_DYN_EXCLUDE_REQUEST_FROM6 ] || [], _extensionConfig.addIntEndpoints !== false ? _internalExcludeEndpoints : []);
                         _addRequestContext = _extensionConfig.addRequestContext;
-                        _isUsingAIHeaders = _distributedTracingMode === 0  || _distributedTracingMode === 1 ;
-                        _isUsingW3CHeaders = _distributedTracingMode === 1  || _distributedTracingMode === 2 ;
+                        var baseDistributedTracingMode = _distributedTracingMode & 15 ;
+                        _isUsingAIHeaders = baseDistributedTracingMode === 0  || baseDistributedTracingMode === 1 ;
+                        _isUsingW3CHeaders = baseDistributedTracingMode === 1  || baseDistributedTracingMode === 2 ;
+                        _isUsingW3CTraceState = !!(_distributedTracingMode & 16 );
                         if (_enableAjaxPerfTracking) {
                             _markPrefix = _ajaxDataId;
                         }
@@ -4764,25 +5320,32 @@
                     return initialized
                         && ajaxValidation;
                 }
-                function _getDistributedTraceCtx() {
+                function _startSpan() {
                     var distributedTraceCtx = null;
                     if (_self[_DYN_CORE ] && _self[_DYN_CORE ].getTraceCtx) {
-                        distributedTraceCtx = _self[_DYN_CORE ].getTraceCtx(false);
+                        distributedTraceCtx = createDistributedTraceContext(_self[_DYN_CORE ].getTraceCtx());
                     }
                     if (!distributedTraceCtx && _context && _context.telemetryTrace) {
                         distributedTraceCtx = createDistributedTraceContextFromTrace(_context.telemetryTrace);
                     }
-                    return distributedTraceCtx;
+                    var newCtx = createDistributedTraceContext(distributedTraceCtx);
+                    newCtx[_DYN_TRACE_ID ] = newCtx[_DYN_TRACE_ID ] || generateW3CId();
+                    newCtx[_DYN_SPAN_ID ] = strSubstr(generateW3CId(), 0, 16);
+                    return createAjaxRecord(newCtx, _self[strDiagLog]());
+                }
+                function _endSpan(ajaxData, dependency, properties) {
+                    if (dependency) {
+                        if (properties !== undefined) {
+                            dependency[STR_PROPERTIES ] = __assignFn(__assignFn({}, dependency.properties), properties);
+                        }
+                        var sysProperties = ajaxData.getPartAProps();
+                        _reportDependencyInternal(_dependencyInitializers, _self[_DYN_CORE ], ajaxData, dependency, properties, sysProperties);
+                    }
                 }
                 function _openHandler(xhr, method, url, async) {
-                    var _a;
-                    var distributedTraceCtx = _getDistributedTraceCtx();
-                    var traceID = (distributedTraceCtx && distributedTraceCtx[_DYN_GET_TRACE_ID ]()) || generateW3CId();
-                    var spanID = strSubstr(generateW3CId(), 0, 16);
                     var xhrRequestData = xhr[AJAX_DATA_CONTAINER] = (xhr[AJAX_DATA_CONTAINER] || { xh: [], i: {} });
                     var ajaxDataCntr = xhrRequestData.i = (xhrRequestData.i || {});
-                    var ajaxData = ajaxDataCntr[_ajaxDataId] = (ajaxDataCntr[_ajaxDataId] || new ajaxRecord(traceID, spanID, _self[strDiagLog](), (_a = _self.core) === null || _a === void 0 ? void 0 : _a.getTraceCtx()));
-                    ajaxData[_DYN_TRACE_FLAGS ] = distributedTraceCtx && distributedTraceCtx[_DYN_GET_TRACE_FLAGS ]();
+                    var ajaxData = ajaxDataCntr[_ajaxDataId] = (ajaxDataCntr[_ajaxDataId] || _startSpan());
                     ajaxData[_DYN_METHOD ] = method;
                     ajaxData[_DYN_REQUEST_URL ] = url;
                     ajaxData.xhrMonitoringState.openDone = true;
@@ -4873,19 +5436,13 @@
                             catch (e) {
                                 _throwInternalWarning(_self, 104 , CUSTOM_REQUEST_CONTEXT_ERROR);
                             }
-                            if (dependency) {
-                                if (properties !== undefined) {
-                                    dependency[STR_PROPERTIES ] = __assignFn(__assignFn({}, dependency.properties), properties);
-                                }
-                                var sysProperties = ajaxData[_DYN_GET_PART_APROPS ]();
-                                _reportDependencyInternal(_dependencyInitializers, _self[_DYN_CORE ], ajaxData, dependency, null, sysProperties);
-                            }
-                            else {
+                            if (!dependency) {
                                 _reportXhrError(null, {
                                     requestSentTime: ajaxData[_DYN_REQUEST_SENT_TIME ],
                                     responseFinishedTime: ajaxData[_DYN_RESPONSE_FINISHED_TI12 ]
                                 });
                             }
+                            _endSpan(ajaxData, dependency, properties);
                         }
                         finally {
                             try {
@@ -4930,13 +5487,13 @@
                             performance_1.mark(markId);
                             var entries = performance_1.getEntriesByName(markId);
                             if (entries && entries[_DYN_LENGTH ] === 1) {
-                                ajaxData[_DYN_PERF_MARK ] = entries[0];
+                                ajaxData.perfMark = entries[0];
                             }
                         }
                     }
                 }
                 function _findPerfResourceEntry(initiatorType, ajaxData, trackCallback, reportError) {
-                    var perfMark = ajaxData[_DYN_PERF_MARK ];
+                    var perfMark = ajaxData.perfMark;
                     var performance = getPerformance();
                     var maxAttempts = _maxAjaxPerfLookupAttempts;
                     var retryDelay = _ajaxPerfLookupDelay;
@@ -4987,12 +5544,7 @@
                     })();
                 }
                 function _createFetchRecord(input, init) {
-                    var _a;
-                    var distributedTraceCtx = _getDistributedTraceCtx();
-                    var traceID = (distributedTraceCtx && distributedTraceCtx[_DYN_GET_TRACE_ID ]()) || generateW3CId();
-                    var spanID = strSubstr(generateW3CId(), 0, 16);
-                    var ajaxData = new ajaxRecord(traceID, spanID, _self[strDiagLog](), (_a = _self.core) === null || _a === void 0 ? void 0 : _a.getTraceCtx());
-                    ajaxData[_DYN_TRACE_FLAGS ] = distributedTraceCtx && distributedTraceCtx[_DYN_GET_TRACE_FLAGS ]();
+                    var ajaxData = _startSpan();
                     ajaxData[_DYN_REQUEST_SENT_TIME ] = dateTimeUtilsNow();
                     ajaxData[_DYN_ERROR_STATUS_TEXT ] = _enableAjaxErrorStatusText;
                     var requestUrl;
@@ -5008,6 +5560,9 @@
                             requestUrl = strSplit(location_1.href, "#")[0];
                         }
                     }
+                    if (_self[_DYN_CORE ] && _self[_DYN_CORE ].config) {
+                        requestUrl = fieldRedaction(requestUrl, _self[_DYN_CORE ].config);
+                    }
                     ajaxData[_DYN_REQUEST_URL ] = requestUrl;
                     var method = "GET";
                     if (init && init[_DYN_METHOD ]) {
@@ -5072,19 +5627,13 @@
                         catch (e) {
                             _throwInternalWarning(_self, 104 , CUSTOM_REQUEST_CONTEXT_ERROR);
                         }
-                        if (dependency) {
-                            if (properties !== undefined) {
-                                dependency[STR_PROPERTIES ] = __assignFn(__assignFn({}, dependency.properties), properties);
-                            }
-                            var sysProperties = ajaxData[_DYN_GET_PART_APROPS ]();
-                            _reportDependencyInternal(_dependencyInitializers, _self[_DYN_CORE ], ajaxData, dependency, null, sysProperties);
-                        }
-                        else {
+                        if (!dependency) {
                             _reportFetchError(14 , null, {
                                 requestSentTime: ajaxData[_DYN_REQUEST_SENT_TIME ],
                                 responseFinishedTime: ajaxData[_DYN_RESPONSE_FINISHED_TI12 ]
                             });
                         }
+                        _endSpan(ajaxData, dependency, properties);
                     }, function (e) {
                         _reportFetchError(18 , e, null);
                     });
@@ -5135,7 +5684,6 @@
 
     exports.AjaxPlugin = AjaxMonitor;
     exports.DfltAjaxCorrelationHeaderExDomains = DfltAjaxCorrelationHeaderExDomains;
-    exports.ajaxRecord = ajaxRecord;
 
 }));
 //# sourceMappingURL=applicationinsights-dependencies-js.js.map