@microsoft/applicationinsights-core-js 3.0.0-beta.2211-03 → 3.0.0-beta.2211-04

package/dist/applicationinsights-core-js.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Core, 3.0.0-beta.2211-03
+ * Application Insights JavaScript SDK - Core, 3.0.0-beta.2211-04
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -825,6 +825,7 @@
     var _DYN_INITIALIZE = "initialize";
     var _DYN_IDENTIFIER = "identifier";
     var _DYN_IS_INITIALIZED = "isInitialized";
+    var _DYN_GET_PLUGIN = "getPlugin";
     var _DYN_POLL_INTERNAL_LOGS = "pollInternalLogs";
     var _DYN_NAME = "name";
     var _DYN_TIME = "time";
@@ -836,10 +837,9 @@
     var _DYN_STOP_POLLING_INTERNA3 = "stopPollingInternalLogs";
     var _DYN_ON_COMPLETE = "onComplete";
     var _DYN_CALL = "call";
-    var _DYN_GET_PLUGIN = "getPlugin";
-    var _DYN_FLUSH = "flush";
     var _DYN_VERSION = "version";
     var _DYN_LOGGING_LEVEL_CONSOL4 = "loggingLevelConsole";
+    var _DYN_CREATE_NEW = "createNew";
     var _DYN_TEARDOWN = "teardown";
     var _DYN_MESSAGE_ID = "messageId";
     var _DYN_MESSAGE = "message";
@@ -849,8 +849,6 @@
     var _DYN_UPDATE = "update";
     var _DYN_GET_NEXT = "getNext";
     var _DYN_SET_NEXT_PLUGIN = "setNextPlugin";
-    var _DYN_CREATE_NEW = "createNew";
-    var _DYN_CONFIG = "config";
     var _DYN_USER_AGENT = "userAgent";
     var _DYN_SPLIT = "split";
     var _DYN_NODE_TYPE = "nodeType";
@@ -1727,7 +1725,7 @@
     }
 
     var _objDefineProperty = ObjDefineProperty;
-    var version = "3.0.0-beta.2211-03";
+    var version = "3.0.0-beta.2211-04";
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _createAccessor(target, prop, value) {
@@ -2221,6 +2219,8 @@
         createDynamicConfig(config, null, logger)[_DYN_WATCH ](configHandler);
     }
 
+    var ChannelControllerPriority = 500;
+
     var listenerFuncs = [STR_EVENTS_SENT, STR_EVENTS_DISCARDED, STR_EVENTS_SEND_REQUEST, STR_PERF_EVENT];
     var _aiNamespace = null;
     var _debugListener;
@@ -2437,1308 +2437,1114 @@
         _getLogger(logger)[_DYN_LOG_INTERNAL_MESSAGE ](severity, message);
     }
 
-    var strExecutionContextKey = "ctx";
-    var strParentContextKey = "ParentContextKey";
-    var strChildrenContextKey = "ChildrenContextKey";
-    var _defaultPerfManager = null;
-    var PerfEvent = /** @class */ (function () {
-        function PerfEvent(name, payloadDetails, isAsync) {
-            var _self = this;
-            _self.start = utcNow();
-            _self[_DYN_NAME ] = name;
-            _self[_DYN_IS_ASYNC ] = isAsync;
-            _self[_DYN_IS_CHILD_EVT ] = function () { return false; };
-            if (isFunction(payloadDetails)) {
-                var theDetails_1;
-                objDefineAccessors(_self, "payload", function () {
-                    if (!theDetails_1 && isFunction(payloadDetails)) {
-                        theDetails_1 = payloadDetails();
-                        payloadDetails = null;
-                    }
-                    return theDetails_1;
-                });
-            }
-            _self[_DYN_GET_CTX ] = function (key) {
-                if (key) {
-                    if (key === PerfEvent[strParentContextKey] || key === PerfEvent[strChildrenContextKey]) {
-                        return _self[key];
-                    }
-                    return (_self[strExecutionContextKey] || {})[key];
-                }
-                return null;
-            };
-            _self[_DYN_SET_CTX ] = function (key, value) {
-                if (key) {
-                    if (key === PerfEvent[strParentContextKey]) {
-                        if (!_self[key]) {
-                            _self[_DYN_IS_CHILD_EVT ] = function () { return true; };
-                        }
-                        _self[key] = value;
-                    }
-                    else if (key === PerfEvent[strChildrenContextKey]) {
-                        _self[key] = value;
-                    }
-                    else {
-                        var ctx = _self[strExecutionContextKey] = _self[strExecutionContextKey] || {};
-                        ctx[key] = value;
-                    }
-                }
-            };
-            _self[_DYN_COMPLETE ] = function () {
-                var childTime = 0;
-                var childEvts = _self[_DYN_GET_CTX ](PerfEvent[strChildrenContextKey]);
-                if (isArray(childEvts)) {
-                    for (var lp = 0; lp < childEvts[_DYN_LENGTH ]; lp++) {
-                        var childEvt = childEvts[lp];
-                        if (childEvt) {
-                            childTime += childEvt[_DYN_TIME ];
-                        }
-                    }
-                }
-                _self[_DYN_TIME ] = utcNow() - _self.start;
-                _self.exTime = _self[_DYN_TIME ] - childTime;
-                _self[_DYN_COMPLETE ] = function () { };
-            };
-        }
-        PerfEvent.ParentContextKey = "parent";
-        PerfEvent.ChildrenContextKey = "childEvts";
-        return PerfEvent;
-    }());
-    var PerfManager = /** @class */ (function () {
-        function PerfManager(manager) {
-            this.ctx = {};
-            dynamicProto(PerfManager, this, function (_self) {
-                _self.create = function (src, payloadDetails, isAsync) {
-                    return new PerfEvent(src, payloadDetails, isAsync);
-                };
-                _self.fire = function (perfEvent) {
-                    if (perfEvent) {
-                        perfEvent[_DYN_COMPLETE ]();
-                        if (manager && isFunction(manager[STR_PERF_EVENT ])) {
-                            manager[STR_PERF_EVENT ](perfEvent);
-                        }
-                    }
-                };
-                _self[_DYN_SET_CTX ] = function (key, value) {
-                    if (key) {
-                        var ctx = _self[strExecutionContextKey] = _self[strExecutionContextKey] || {};
-                        ctx[key] = value;
-                    }
-                };
-                _self[_DYN_GET_CTX ] = function (key) {
-                    return (_self[strExecutionContextKey] || {})[key];
-                };
-            });
-        }
-        PerfManager.__ieDyn=1;
-        return PerfManager;
-    }());
-    var doPerfActiveKey = "CoreUtils.doPerf";
-    function doPerf(mgrSource, getSource, func, details, isAsync) {
-        if (mgrSource) {
-            var perfMgr = mgrSource;
-            if (perfMgr[STR_GET_PERF_MGR]) {
-                perfMgr = perfMgr[STR_GET_PERF_MGR]();
-            }
-            if (perfMgr) {
-                var perfEvt = void 0;
-                var currentActive = perfMgr[_DYN_GET_CTX ](doPerfActiveKey);
-                try {
-                    perfEvt = perfMgr.create(getSource(), details, isAsync);
-                    if (perfEvt) {
-                        if (currentActive && perfEvt[_DYN_SET_CTX ]) {
-                            perfEvt[_DYN_SET_CTX ](PerfEvent[strParentContextKey], currentActive);
-                            if (currentActive[_DYN_GET_CTX ] && currentActive[_DYN_SET_CTX ]) {
-                                var children = currentActive[_DYN_GET_CTX ](PerfEvent[strChildrenContextKey]);
-                                if (!children) {
-                                    children = [];
-                                    currentActive[_DYN_SET_CTX ](PerfEvent[strChildrenContextKey], children);
-                                }
-                                children[_DYN_PUSH ](perfEvt);
-                            }
-                        }
-                        perfMgr[_DYN_SET_CTX ](doPerfActiveKey, perfEvt);
-                        return func(perfEvt);
-                    }
-                }
-                catch (ex) {
-                    if (perfEvt && perfEvt[_DYN_SET_CTX ]) {
-                        perfEvt[_DYN_SET_CTX ]("exception", ex);
-                    }
-                }
-                finally {
-                    if (perfEvt) {
-                        perfMgr.fire(perfEvt);
-                    }
-                    perfMgr[_DYN_SET_CTX ](doPerfActiveKey, currentActive);
-                }
-            }
+    var _a$2, _b;
+    var strToGMTString = "toGMTString";
+    var strToUTCString = "toUTCString";
+    var strCookie = "cookie";
+    var strExpires = "expires";
+    var strIsCookieUseDisabled = "isCookieUseDisabled";
+    var strDisableCookiesUsage = "disableCookiesUsage";
+    var strConfigCookieMgr = "_ckMgr";
+    var _supportsCookies = null;
+    var _allowUaSameSite = null;
+    var _parsedCookieValue = null;
+    var _doc = getDocument();
+    var _cookieCache = {};
+    var _globalCookieConfig = {};
+    var defaultConfig$1 = objDeepFreeze((_a$2 = {},
+        _a$2[STR_DOMAIN] = { fb: "cookieDomain", dfVal: isNotNullOrUndefined },
+        _a$2.path = { fb: "cookiePath", dfVal: isNotNullOrUndefined },
+        _a$2.enabled = UNDEFINED_VALUE,
+        _a$2));
+    var rootDefaultConfig = (_b = {
+            cookieCfg: {},
+            cookieDomain: UNDEFINED_VALUE,
+            cookiePath: UNDEFINED_VALUE
+        },
+        _b[strDisableCookiesUsage] = UNDEFINED_VALUE,
+        _b);
+    function _gblCookieMgr(config, logger) {
+        var inst = createCookieMgr[strConfigCookieMgr] || _globalCookieConfig[strConfigCookieMgr];
+        if (!inst) {
+            inst = createCookieMgr[strConfigCookieMgr] = createCookieMgr(config, logger);
+            _globalCookieConfig[strConfigCookieMgr] = inst;
         }
-        return func();
-    }
-    function setGblPerfMgr(perfManager) {
-        _defaultPerfManager = perfManager;
-    }
-    function getGblPerfMgr() {
-        return _defaultPerfManager;
-    }
-
-    var Undefined = strShimUndefined;
-    function newGuid() {
-        var uuid = generateW3CId();
-        return strSubstring(uuid, 0, 8) + "-" + strSubstring(uuid, 8, 12) + "-" + strSubstring(uuid, 12, 16) + "-" + strSubstring(uuid, 16, 20) + "-" + strSubstring(uuid, 20);
+        return inst;
     }
-    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];
+    function _isMgrEnabled(cookieMgr) {
+        if (cookieMgr) {
+            return cookieMgr.isEnabled();
         }
-        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);
+        return true;
     }
-
-    var TRACE_PARENT_REGEX = /^([\da-f]{2})-([\da-f]{32})-([\da-f]{16})-([\da-f]{2})(-[^\s]{1,64})?$/i;
-    var DEFAULT_VERSION = "00";
-    var INVALID_VERSION = "ff";
-    var INVALID_TRACE_ID = "00000000000000000000000000000000";
-    var INVALID_SPAN_ID = "0000000000000000";
-    var SAMPLED_FLAG = 0x01;
-    function _isValid(value, len, invalidValue) {
-        if (value && value[_DYN_LENGTH ] === len && value !== invalidValue) {
-            return !!value.match(/^[\da-f]*$/i);
+    function _isIgnoredCookie(cookieMgrCfg, name) {
+        if (name && cookieMgrCfg && isArray(cookieMgrCfg.ignoreCookies)) {
+            return arrIndexOf(cookieMgrCfg.ignoreCookies, name) !== -1;
         }
         return false;
     }
-    function _formatValue(value, len, defValue) {
-        if (_isValid(value, len)) {
-            return value;
+    function _isBlockedCookie(cookieMgrCfg, name) {
+        if (name && cookieMgrCfg && isArray(cookieMgrCfg.blockedCookies)) {
+            if (arrIndexOf(cookieMgrCfg.blockedCookies, name) !== -1) {
+                return true;
+            }
         }
-        return defValue;
+        return _isIgnoredCookie(cookieMgrCfg, name);
     }
-    function _formatFlags(value) {
-        if (isNaN(value) || value < 0 || value > 255) {
-            value = 0x01;
+    function safeGetCookieMgr(core, config) {
+        var cookieMgr;
+        if (core) {
+            cookieMgr = core.getCookieMgr();
         }
-        var result = value.toString(16);
-        while (result[_DYN_LENGTH ] < 2) {
-            result = "0" + result;
+        else if (config) {
+            var cookieCfg = config.cookieCfg;
+            if (cookieCfg && cookieCfg[strConfigCookieMgr]) {
+                cookieMgr = cookieCfg[strConfigCookieMgr];
+            }
+            else {
+                cookieMgr = createCookieMgr(config);
+            }
         }
-        return result;
+        if (!cookieMgr) {
+            cookieMgr = _gblCookieMgr(config, (core || {})[_DYN_LOGGER ]);
+        }
+        return cookieMgr;
     }
-    function createTraceParent(traceId, spanId, flags, version) {
-        var _a;
-        return _a = {},
-            _a[_DYN_VERSION ] = _isValid(version, 2, INVALID_VERSION) ? version : DEFAULT_VERSION,
-            _a[_DYN_TRACE_ID ] = isValidTraceId(traceId) ? traceId : generateW3CId(),
-            _a[_DYN_SPAN_ID ] = isValidSpanId(spanId) ? spanId : strLeft(generateW3CId(), 16),
-            _a.traceFlags = flags >= 0 && flags <= 0xFF ? flags : 1,
-            _a;
+    function createCookieMgr(rootConfig, logger) {
+        var cookieMgrConfig;
+        var _path;
+        var _domain;
+        var _enabled;
+        var _getCookieFn;
+        var _setCookieFn;
+        var _delCookieFn;
+        rootConfig = createDynamicConfig(rootConfig || _globalCookieConfig, null, logger).cfg;
+        onConfigChange(rootConfig, function (details) {
+            details[_DYN_SET_DF ](details.cfg, rootDefaultConfig);
+            cookieMgrConfig = details[_DYN_SET_DF ](details.cfg.cookieCfg, defaultConfig$1);
+            var isEnabled = cookieMgrConfig.enabled;
+            if (isNullOrUndefined(isEnabled)) {
+                var cookieEnabled = void 0;
+                if (!isUndefined(rootConfig[strIsCookieUseDisabled])) {
+                    cookieEnabled = !rootConfig[strIsCookieUseDisabled];
+                }
+                if (!isUndefined(rootConfig[strDisableCookiesUsage])) {
+                    cookieEnabled = !rootConfig[strDisableCookiesUsage];
+                }
+                isEnabled = cookieEnabled;
+            }
+            _path = cookieMgrConfig[STR_PATH ] || "/";
+            _domain = cookieMgrConfig[STR_DOMAIN ];
+            _enabled = isEnabled !== false;
+            _getCookieFn = cookieMgrConfig.getCookie || _getCookieValue;
+            _setCookieFn = cookieMgrConfig.setCookie || _setCookieValue;
+            _delCookieFn = cookieMgrConfig.delCookie || _setCookieValue;
+        }, logger);
+        var cookieMgr = {
+            isEnabled: function () {
+                var enabled = _enabled && areCookiesSupported(logger);
+                var gblManager = _globalCookieConfig[strConfigCookieMgr];
+                if (enabled && gblManager && cookieMgr !== gblManager) {
+                    enabled = _isMgrEnabled(gblManager);
+                }
+                return enabled;
+            },
+            setEnabled: function (value) {
+                _enabled = value !== false;
+            },
+            set: function (name, value, maxAgeSec, domain, path) {
+                var result = false;
+                if (_isMgrEnabled(cookieMgr) && !_isBlockedCookie(cookieMgrConfig, name)) {
+                    var values = {};
+                    var theValue = strTrim(value || STR_EMPTY);
+                    var idx = strIndexOf(theValue, ";");
+                    if (idx !== -1) {
+                        theValue = strTrim(strLeft(value, idx));
+                        values = _extractParts(strSubstring(value, idx + 1));
+                    }
+                    setValue(values, STR_DOMAIN, domain || _domain, isTruthy, isUndefined);
+                    if (!isNullOrUndefined(maxAgeSec)) {
+                        var _isIE = isIE();
+                        if (isUndefined(values[strExpires])) {
+                            var nowMs = utcNow();
+                            var expireMs = nowMs + (maxAgeSec * 1000);
+                            if (expireMs > 0) {
+                                var expiry = new Date();
+                                expiry.setTime(expireMs);
+                                setValue(values, strExpires, _formatDate(expiry, !_isIE ? strToUTCString : strToGMTString) || _formatDate(expiry, _isIE ? strToGMTString : strToUTCString) || STR_EMPTY, isTruthy);
+                            }
+                        }
+                        if (!_isIE) {
+                            setValue(values, "max-age", STR_EMPTY + maxAgeSec, null, isUndefined);
+                        }
+                    }
+                    var location_1 = getLocation();
+                    if (location_1 && location_1.protocol === "https:") {
+                        setValue(values, "secure", null, null, isUndefined);
+                        if (_allowUaSameSite === null) {
+                            _allowUaSameSite = !uaDisallowsSameSiteNone((getNavigator() || {})[_DYN_USER_AGENT ]);
+                        }
+                        if (_allowUaSameSite) {
+                            setValue(values, "SameSite", "None", null, isUndefined);
+                        }
+                    }
+                    setValue(values, STR_PATH, path || _path, null, isUndefined);
+                    _setCookieFn(name, _formatCookieValue(theValue, values));
+                    result = true;
+                }
+                return result;
+            },
+            get: function (name) {
+                var value = STR_EMPTY;
+                if (_isMgrEnabled(cookieMgr) && !_isIgnoredCookie(cookieMgrConfig, name)) {
+                    value = _getCookieFn(name);
+                }
+                return value;
+            },
+            del: function (name, path) {
+                var result = false;
+                if (_isMgrEnabled(cookieMgr)) {
+                    result = cookieMgr.purge(name, path);
+                }
+                return result;
+            },
+            purge: function (name, path) {
+                var _a;
+                var result = false;
+                if (areCookiesSupported(logger)) {
+                    var values = (_a = {},
+                        _a[STR_PATH] = path ? path : "/",
+                        _a[strExpires] = "Thu, 01 Jan 1970 00:00:01 GMT",
+                        _a);
+                    if (!isIE()) {
+                        values["max-age"] = "0";
+                    }
+                    _delCookieFn(name, _formatCookieValue(STR_EMPTY, values));
+                    result = true;
+                }
+                return result;
+            }
+        };
+        cookieMgr[strConfigCookieMgr] = cookieMgr;
+        return cookieMgr;
     }
-    function parseTraceParent(value) {
-        var _a;
-        if (!value) {
-            return null;
-        }
-        if (isArray(value)) {
-            value = value[0] || "";
-        }
-        if (!value || !isString(value) || value[_DYN_LENGTH ] > 8192) {
-            return null;
+    function areCookiesSupported(logger) {
+        if (_supportsCookies === null) {
+            _supportsCookies = false;
+            try {
+                var doc = _doc || {};
+                _supportsCookies = doc[strCookie] !== undefined;
+            }
+            catch (e) {
+                _throwInternal(logger, 2 , 68 , "Cannot access document.cookie - " + getExceptionName(e), { exception: dumpObj(e) });
+            }
         }
-        var match = TRACE_PARENT_REGEX.exec(strTrim(value));
-        if (!match ||
-            match[1] === INVALID_VERSION ||
-            match[2] === INVALID_TRACE_ID ||
-            match[3] === INVALID_SPAN_ID) {
-            return null;
+        return _supportsCookies;
+    }
+    function _extractParts(theValue) {
+        var values = {};
+        if (theValue && theValue[_DYN_LENGTH ]) {
+            var parts = strTrim(theValue)[_DYN_SPLIT ](";");
+            arrForEach(parts, function (thePart) {
+                thePart = strTrim(thePart || STR_EMPTY);
+                if (thePart) {
+                    var idx = strIndexOf(thePart, "=");
+                    if (idx === -1) {
+                        values[thePart] = null;
+                    }
+                    else {
+                        values[strTrim(strLeft(thePart, idx))] = strTrim(strSubstring(thePart, idx + 1));
+                    }
+                }
+            });
         }
-        return _a = {},
-            _a[_DYN_VERSION ] = (match[1] || STR_EMPTY)[_DYN_TO_LOWER_CASE ](),
-            _a.traceId = (match[2] || STR_EMPTY)[_DYN_TO_LOWER_CASE ](),
-            _a.spanId = (match[3] || STR_EMPTY)[_DYN_TO_LOWER_CASE ](),
-            _a[_DYN_TRACE_FLAGS ] = parseInt(match[4], 16),
-            _a;
+        return values;
     }
-    function isValidTraceId(value) {
-        return _isValid(value, 32, INVALID_TRACE_ID);
+    function _formatDate(theDate, func) {
+        if (isFunction(theDate[func])) {
+            return theDate[func]();
+        }
+        return null;
     }
-    function isValidSpanId(value) {
-        return _isValid(value, 16, INVALID_SPAN_ID);
+    function _formatCookieValue(value, values) {
+        var cookieValue = value || STR_EMPTY;
+        objForEachKey(values, function (name, theValue) {
+            cookieValue += "; " + name + (!isNullOrUndefined(theValue) ? "=" + theValue : STR_EMPTY);
+        });
+        return cookieValue;
     }
-    function isValidTraceParent(value) {
-        if (!value ||
-            !_isValid(value[_DYN_VERSION ], 2, INVALID_VERSION) ||
-            !_isValid(value[_DYN_TRACE_ID ], 32, INVALID_TRACE_ID) ||
-            !_isValid(value[_DYN_SPAN_ID ], 16, INVALID_SPAN_ID) ||
-            !_isValid(_formatFlags(value[_DYN_TRACE_FLAGS ]), 2)) {
-            return false;
+    function _getCookieValue(name) {
+        var cookieValue = STR_EMPTY;
+        if (_doc) {
+            var theCookie = _doc[strCookie] || STR_EMPTY;
+            if (_parsedCookieValue !== theCookie) {
+                _cookieCache = _extractParts(theCookie);
+                _parsedCookieValue = theCookie;
+            }
+            cookieValue = strTrim(_cookieCache[name] || STR_EMPTY);
         }
-        return true;
+        return cookieValue;
     }
-    function isSampledFlag(value) {
-        if (isValidTraceParent(value)) {
-            return (value[_DYN_TRACE_FLAGS ] & SAMPLED_FLAG) === SAMPLED_FLAG;
+    function _setCookieValue(name, cookieValue) {
+        if (_doc) {
+            _doc[strCookie] = name + "=" + cookieValue;
         }
-        return false;
     }
-    function formatTraceParent(value) {
-        if (value) {
-            var flags = _formatFlags(value[_DYN_TRACE_FLAGS ]);
-            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());
+    function uaDisallowsSameSiteNone(userAgent) {
+        if (!isString(userAgent)) {
+            return false;
         }
-        return "";
-    }
-    function findW3cTraceParent() {
-        var name = "traceparent";
-        var traceParent = parseTraceParent(findMetaTag(name));
-        if (!traceParent) {
-            traceParent = parseTraceParent(findNamedServerTiming(name));
+        if (strContains(userAgent, "CPU iPhone OS 12") || strContains(userAgent, "iPad; CPU OS 12")) {
+            return true;
         }
-        return traceParent;
+        if (strContains(userAgent, "Macintosh; Intel Mac OS X 10_14") && strContains(userAgent, "Version/") && strContains(userAgent, "Safari")) {
+            return true;
+        }
+        if (strContains(userAgent, "Macintosh; Intel Mac OS X 10_14") && strEndsWith(userAgent, "AppleWebKit/605.1.15 (KHTML, like Gecko)")) {
+            return true;
+        }
+        if (strContains(userAgent, "Chrome/5") || strContains(userAgent, "Chrome/6")) {
+            return true;
+        }
+        if (strContains(userAgent, "UnrealEngine") && !strContains(userAgent, "Chrome")) {
+            return true;
+        }
+        if (strContains(userAgent, "UCBrowser/12") || strContains(userAgent, "UCBrowser/11")) {
+            return true;
+        }
+        return false;
     }
 
-    var pluginStateData = createElmNodeData("plugin");
-    function _getPluginState(plugin) {
-        return pluginStateData.get(plugin, "state", {}, true);
-    }
-    function initializePlugins(processContext, extensions) {
-        var initPlugins = [];
-        var lastPlugin = null;
-        var proxy = processContext[_DYN_GET_NEXT ]();
-        var pluginState;
-        while (proxy) {
-            var thePlugin = proxy[_DYN_GET_PLUGIN ]();
-            if (thePlugin) {
-                if (lastPlugin && lastPlugin[_DYN_SET_NEXT_PLUGIN ] && thePlugin[STR_PROCESS_TELEMETRY ]) {
-                    lastPlugin[_DYN_SET_NEXT_PLUGIN ](thePlugin);
-                }
-                var isInitialized = false;
-                if (isFunction(thePlugin[_DYN_IS_INITIALIZED ])) {
-                    isInitialized = thePlugin[_DYN_IS_INITIALIZED ]();
+    var defaultValues$1 = {
+        perfEvtsSendAll: false
+    };
+    function _runListeners(listeners, name, isAsync, callback) {
+        arrForEach(listeners, function (listener) {
+            if (listener && listener[name]) {
+                if (isAsync) {
+                    scheduleTimeout(function () { return callback(listener); }, 0);
                 }
                 else {
-                    pluginState = _getPluginState(thePlugin);
-                    isInitialized = pluginState[_DYN_IS_INITIALIZED ];
-                }
-                if (!isInitialized) {
-                    initPlugins[_DYN_PUSH ](thePlugin);
+                    try {
+                        callback(listener);
+                    }
+                    catch (e) {
+                    }
                 }
-                lastPlugin = thePlugin;
-                proxy = proxy[_DYN_GET_NEXT ]();
-            }
-        }
-        arrForEach(initPlugins, function (thePlugin) {
-            var core = processContext[STR_CORE ]();
-            thePlugin[_DYN_INITIALIZE ](processContext.getCfg(), core, extensions, processContext[_DYN_GET_NEXT ]());
-            pluginState = _getPluginState(thePlugin);
-            if (!thePlugin[STR_CORE] && !pluginState[STR_CORE]) {
-                pluginState[STR_CORE] = core;
             }
-            pluginState[_DYN_IS_INITIALIZED ] = true;
-            delete pluginState[_DYN_TEARDOWN ];
         });
     }
-    function sortPlugins(plugins) {
-        return plugins.sort(function (extA, extB) {
-            var result = 0;
-            if (extB) {
-                var bHasProcess = extB[STR_PROCESS_TELEMETRY];
-                if (extA[STR_PROCESS_TELEMETRY]) {
-                    result = bHasProcess ? extA[STR_PRIORITY] - extB[STR_PRIORITY] : 1;
-                }
-                else if (bHasProcess) {
-                    result = -1;
-                }
-            }
-            else {
-                result = extA ? 1 : -1;
-            }
-            return result;
-        });
-    }
-    function unloadComponents(components, unloadCtx, unloadState, asyncCallback) {
-        var idx = 0;
-        function _doUnload() {
-            while (idx < components[_DYN_LENGTH ]) {
-                var component = components[idx++];
-                if (component) {
-                    var func = component._doUnload || component[_DYN__DO_TEARDOWN ];
-                    if (isFunction(func)) {
-                        if (func[_DYN_CALL ](component, unloadCtx, unloadState, _doUnload) === true) {
-                            return true;
+    var NotificationManager = /** @class */ (function () {
+        function NotificationManager(config) {
+            this.listeners = [];
+            var perfEvtsSendAll;
+            var cfgHandler = createDynamicConfig(config, defaultValues$1);
+            cfgHandler[_DYN_WATCH ](function (details) {
+                perfEvtsSendAll = !!details.cfg.perfEvtsSendAll;
+            });
+            dynamicProto(NotificationManager, this, function (_self) {
+                _self[_DYN_ADD_NOTIFICATION_LIS1 ] = function (listener) {
+                    _self.listeners[_DYN_PUSH ](listener);
+                };
+                _self[_DYN_REMOVE_NOTIFICATION_2 ] = function (listener) {
+                    var index = arrIndexOf(_self[_DYN_LISTENERS ], listener);
+                    while (index > -1) {
+                        _self.listeners[_DYN_SPLICE ](index, 1);
+                        index = arrIndexOf(_self[_DYN_LISTENERS ], listener);
+                    }
+                };
+                _self[STR_EVENTS_SENT ] = function (events) {
+                    _runListeners(_self[_DYN_LISTENERS ], STR_EVENTS_SENT, true, function (listener) {
+                        listener[STR_EVENTS_SENT ](events);
+                    });
+                };
+                _self[STR_EVENTS_DISCARDED ] = function (events, reason) {
+                    _runListeners(_self[_DYN_LISTENERS ], STR_EVENTS_DISCARDED, true, function (listener) {
+                        listener[STR_EVENTS_DISCARDED ](events, reason);
+                    });
+                };
+                _self[STR_EVENTS_SEND_REQUEST ] = function (sendReason, isAsync) {
+                    _runListeners(_self[_DYN_LISTENERS ], STR_EVENTS_SEND_REQUEST, isAsync, function (listener) {
+                        listener[STR_EVENTS_SEND_REQUEST ](sendReason, isAsync);
+                    });
+                };
+                _self[STR_PERF_EVENT ] = function (perfEvent) {
+                    if (perfEvent) {
+                        if (perfEvtsSendAll || !perfEvent[_DYN_IS_CHILD_EVT ]()) {
+                            _runListeners(_self[_DYN_LISTENERS ], STR_PERF_EVENT, false, function (listener) {
+                                if (perfEvent[_DYN_IS_ASYNC ]) {
+                                    scheduleTimeout(function () { return listener[STR_PERF_EVENT ](perfEvent); }, 0);
+                                }
+                                else {
+                                    listener[STR_PERF_EVENT ](perfEvent);
+                                }
+                            });
                         }
                     }
-                }
-            }
+                };
+            });
         }
-        return _doUnload();
-    }
-    function createDistributedTraceContext(parentCtx) {
-        var trace = {};
-        return {
-            getName: function () {
-                return trace[_DYN_NAME ];
-            },
-            setName: function (newValue) {
-                parentCtx && parentCtx.setName(newValue);
-                trace[_DYN_NAME ] = newValue;
-            },
-            getTraceId: function () {
-                return trace[_DYN_TRACE_ID ];
-            },
-            setTraceId: function (newValue) {
-                parentCtx && parentCtx.setTraceId(newValue);
-                if (isValidTraceId(newValue)) {
-                    trace[_DYN_TRACE_ID ] = newValue;
-                }
-            },
-            getSpanId: function () {
-                return trace[_DYN_SPAN_ID ];
-            },
-            setSpanId: function (newValue) {
-                parentCtx && parentCtx.setSpanId(newValue);
-                if (isValidSpanId(newValue)) {
-                    trace[_DYN_SPAN_ID ] = newValue;
-                }
-            },
-            getTraceFlags: function () {
-                return trace[_DYN_TRACE_FLAGS ];
-            },
-            setTraceFlags: function (newTraceFlags) {
-                parentCtx && parentCtx.setTraceFlags(newTraceFlags);
-                trace[_DYN_TRACE_FLAGS ] = newTraceFlags;
-            }
-        };
-    }
+        NotificationManager.__ieDyn=1;
+        return NotificationManager;
+    }());
 
-    var strTelemetryPluginChain = "TelemetryPluginChain";
-    var strHasRunFlags = "_hasRun";
-    var strGetTelCtx = "_getTelCtx";
-    var _chainId = 0;
-    function _getNextProxyStart(proxy, core, startAt) {
-        while (proxy) {
-            if (proxy[_DYN_GET_PLUGIN ]() === startAt) {
-                return proxy;
-            }
-            proxy = proxy[_DYN_GET_NEXT ]();
-        }
-        return createTelemetryProxyChain([startAt], core[_DYN_CONFIG ] || {}, core);
-    }
-    function _createInternalContext(telemetryChain, dynamicHandler, core, startAt) {
-        var _nextProxy = null;
-        var _onComplete = [];
-        if (!dynamicHandler) {
-            dynamicHandler = createDynamicConfig({}, null, core[_DYN_LOGGER ]);
-        }
-        if (startAt !== null) {
-            _nextProxy = startAt ? _getNextProxyStart(telemetryChain, core, startAt) : telemetryChain;
-        }
-        var context = {
-            _next: _moveNext,
-            ctx: {
-                core: function () {
-                    return core;
-                },
-                diagLog: function () {
-                    return safeGetLogger(core, dynamicHandler.cfg);
-                },
-                getCfg: function () {
-                    return dynamicHandler.cfg;
-                },
-                getExtCfg: _resolveExtCfg,
-                getConfig: _getConfig,
-                hasNext: function () {
-                    return !!_nextProxy;
-                },
-                getNext: function () {
-                    return _nextProxy;
-                },
-                setNext: function (nextPlugin) {
-                    _nextProxy = nextPlugin;
-                },
-                iterate: _iterateChain,
-                onComplete: _addOnComplete
-            }
-        };
-        function _addOnComplete(onComplete, that) {
-            var args = [];
-            for (var _i = 2; _i < arguments.length; _i++) {
-                args[_i - 2] = arguments[_i];
-            }
-            if (onComplete) {
-                _onComplete[_DYN_PUSH ]({
-                    func: onComplete,
-                    self: !isUndefined(that) ? that : context.ctx,
-                    args: args
-                });
-            }
-        }
-        function _moveNext() {
-            var nextProxy = _nextProxy;
-            _nextProxy = nextProxy ? nextProxy[_DYN_GET_NEXT ]() : null;
-            if (!nextProxy) {
-                var onComplete = _onComplete;
-                if (onComplete && onComplete[_DYN_LENGTH ] > 0) {
-                    arrForEach(onComplete, function (completeDetails) {
-                        try {
-                            completeDetails.func[_DYN_CALL ](completeDetails.self, completeDetails.args);
-                        }
-                        catch (e) {
-                            _throwInternal(core[_DYN_LOGGER ], 2 , 73 , "Unexpected Exception during onComplete - " + dumpObj(e));
-                        }
-                    });
-                    _onComplete = [];
-                }
+    var strExecutionContextKey = "ctx";
+    var strParentContextKey = "ParentContextKey";
+    var strChildrenContextKey = "ChildrenContextKey";
+    var _defaultPerfManager = null;
+    var PerfEvent = /** @class */ (function () {
+        function PerfEvent(name, payloadDetails, isAsync) {
+            var _self = this;
+            _self.start = utcNow();
+            _self[_DYN_NAME ] = name;
+            _self[_DYN_IS_ASYNC ] = isAsync;
+            _self[_DYN_IS_CHILD_EVT ] = function () { return false; };
+            if (isFunction(payloadDetails)) {
+                var theDetails_1;
+                objDefineAccessors(_self, "payload", function () {
+                    if (!theDetails_1 && isFunction(payloadDetails)) {
+                        theDetails_1 = payloadDetails();
+                        payloadDetails = null;
+                    }
+                    return theDetails_1;
+                });
             }
-            return nextProxy;
-        }
-        function _getExtCfg(identifier, createIfMissing) {
-            var idCfg = null;
-            var cfg = dynamicHandler.cfg;
-            if (cfg && identifier) {
-                var extCfg = cfg[STR_EXTENSION_CONFIG ];
-                if (!extCfg && createIfMissing) {
-                    extCfg = {};
+            _self[_DYN_GET_CTX ] = function (key) {
+                if (key) {
+                    if (key === PerfEvent[strParentContextKey] || key === PerfEvent[strChildrenContextKey]) {
+                        return _self[key];
+                    }
+                    return (_self[strExecutionContextKey] || {})[key];
                 }
-                dynamicHandler.set(cfg, STR_EXTENSION_CONFIG, extCfg);
-                extCfg = cfg[STR_EXTENSION_CONFIG ];
-                if (extCfg) {
-                    idCfg = extCfg[identifier];
-                    if (!idCfg && createIfMissing) {
-                        idCfg = {};
+                return null;
+            };
+            _self[_DYN_SET_CTX ] = function (key, value) {
+                if (key) {
+                    if (key === PerfEvent[strParentContextKey]) {
+                        if (!_self[key]) {
+                            _self[_DYN_IS_CHILD_EVT ] = function () { return true; };
+                        }
+                        _self[key] = value;
+                    }
+                    else if (key === PerfEvent[strChildrenContextKey]) {
+                        _self[key] = value;
+                    }
+                    else {
+                        var ctx = _self[strExecutionContextKey] = _self[strExecutionContextKey] || {};
+                        ctx[key] = value;
                     }
-                    dynamicHandler.set(extCfg, identifier, idCfg);
-                    idCfg = extCfg[identifier];
                 }
-            }
-            return idCfg;
+            };
+            _self[_DYN_COMPLETE ] = function () {
+                var childTime = 0;
+                var childEvts = _self[_DYN_GET_CTX ](PerfEvent[strChildrenContextKey]);
+                if (isArray(childEvts)) {
+                    for (var lp = 0; lp < childEvts[_DYN_LENGTH ]; lp++) {
+                        var childEvt = childEvts[lp];
+                        if (childEvt) {
+                            childTime += childEvt[_DYN_TIME ];
+                        }
+                    }
+                }
+                _self[_DYN_TIME ] = utcNow() - _self.start;
+                _self.exTime = _self[_DYN_TIME ] - childTime;
+                _self[_DYN_COMPLETE ] = function () { };
+            };
         }
-        function _resolveExtCfg(identifier, defaultValues) {
-            var newConfig = _getExtCfg(identifier, true);
-            if (defaultValues) {
-                objForEachKey(defaultValues, function (field, defaultValue) {
-                    if (isNullOrUndefined(newConfig[field])) {
-                        var cfgValue = dynamicHandler.cfg[field];
-                        if (cfgValue || !isNullOrUndefined(cfgValue)) {
-                            newConfig[field] = cfgValue;
+        PerfEvent.ParentContextKey = "parent";
+        PerfEvent.ChildrenContextKey = "childEvts";
+        return PerfEvent;
+    }());
+    var PerfManager = /** @class */ (function () {
+        function PerfManager(manager) {
+            this.ctx = {};
+            dynamicProto(PerfManager, this, function (_self) {
+                _self.create = function (src, payloadDetails, isAsync) {
+                    return new PerfEvent(src, payloadDetails, isAsync);
+                };
+                _self.fire = function (perfEvent) {
+                    if (perfEvent) {
+                        perfEvent[_DYN_COMPLETE ]();
+                        if (manager && isFunction(manager[STR_PERF_EVENT ])) {
+                            manager[STR_PERF_EVENT ](perfEvent);
                         }
                     }
-                    _applyDefaultValue(dynamicHandler, newConfig, field, defaultValue);
-                });
-            }
-            return dynamicHandler[_DYN_SET_DF ](newConfig, defaultValues);
+                };
+                _self[_DYN_SET_CTX ] = function (key, value) {
+                    if (key) {
+                        var ctx = _self[strExecutionContextKey] = _self[strExecutionContextKey] || {};
+                        ctx[key] = value;
+                    }
+                };
+                _self[_DYN_GET_CTX ] = function (key) {
+                    return (_self[strExecutionContextKey] || {})[key];
+                };
+            });
         }
-        function _getConfig(identifier, field, defaultValue) {
-            if (defaultValue === void 0) { defaultValue = false; }
-            var theValue;
-            var extConfig = _getExtCfg(identifier, false);
-            var rootConfig = dynamicHandler.cfg;
-            if (extConfig && (extConfig[field] || !isNullOrUndefined(extConfig[field]))) {
-                theValue = extConfig[field];
-            }
-            else if (rootConfig[field] || !isNullOrUndefined(rootConfig[field])) {
-                theValue = rootConfig[field];
+        PerfManager.__ieDyn=1;
+        return PerfManager;
+    }());
+    var doPerfActiveKey = "CoreUtils.doPerf";
+    function doPerf(mgrSource, getSource, func, details, isAsync) {
+        if (mgrSource) {
+            var perfMgr = mgrSource;
+            if (perfMgr[STR_GET_PERF_MGR]) {
+                perfMgr = perfMgr[STR_GET_PERF_MGR]();
             }
-            return (theValue || !isNullOrUndefined(theValue)) ? theValue : defaultValue;
-        }
-        function _iterateChain(cb) {
-            var nextPlugin;
-            while (!!(nextPlugin = context._next())) {
-                var plugin = nextPlugin[_DYN_GET_PLUGIN ]();
-                if (plugin) {
-                    cb(plugin);
+            if (perfMgr) {
+                var perfEvt = void 0;
+                var currentActive = perfMgr[_DYN_GET_CTX ](doPerfActiveKey);
+                try {
+                    perfEvt = perfMgr.create(getSource(), details, isAsync);
+                    if (perfEvt) {
+                        if (currentActive && perfEvt[_DYN_SET_CTX ]) {
+                            perfEvt[_DYN_SET_CTX ](PerfEvent[strParentContextKey], currentActive);
+                            if (currentActive[_DYN_GET_CTX ] && currentActive[_DYN_SET_CTX ]) {
+                                var children = currentActive[_DYN_GET_CTX ](PerfEvent[strChildrenContextKey]);
+                                if (!children) {
+                                    children = [];
+                                    currentActive[_DYN_SET_CTX ](PerfEvent[strChildrenContextKey], children);
+                                }
+                                children[_DYN_PUSH ](perfEvt);
+                            }
+                        }
+                        perfMgr[_DYN_SET_CTX ](doPerfActiveKey, perfEvt);
+                        return func(perfEvt);
+                    }
+                }
+                catch (ex) {
+                    if (perfEvt && perfEvt[_DYN_SET_CTX ]) {
+                        perfEvt[_DYN_SET_CTX ]("exception", ex);
+                    }
+                }
+                finally {
+                    if (perfEvt) {
+                        perfMgr.fire(perfEvt);
+                    }
+                    perfMgr[_DYN_SET_CTX ](doPerfActiveKey, currentActive);
                 }
             }
         }
-        return context;
+        return func();
     }
-    function createProcessTelemetryContext(telemetryChain, cfg, core, startAt) {
-        var config = createDynamicConfig(cfg);
-        var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
-        var context = internalContext.ctx;
-        function _processNext(env) {
-            var nextPlugin = internalContext._next();
-            if (nextPlugin) {
-                nextPlugin[STR_PROCESS_TELEMETRY ](env, context);
-            }
-            return !nextPlugin;
-        }
-        function _createNew(plugins, startAt) {
-            if (plugins === void 0) { plugins = null; }
-            if (isArray(plugins)) {
-                plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt);
-            }
-            return createProcessTelemetryContext(plugins || context[_DYN_GET_NEXT ](), config.cfg, core, startAt);
-        }
-        context[_DYN_PROCESS_NEXT ] = _processNext;
-        context[_DYN_CREATE_NEW ] = _createNew;
-        return context;
+    function setGblPerfMgr(perfManager) {
+        _defaultPerfManager = perfManager;
     }
-    function createProcessTelemetryUnloadContext(telemetryChain, core, startAt) {
-        var config = createDynamicConfig(core[_DYN_CONFIG ]);
-        var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
-        var context = internalContext.ctx;
-        function _processNext(unloadState) {
-            var nextPlugin = internalContext._next();
-            nextPlugin && nextPlugin.unload(context, unloadState);
-            return !nextPlugin;
-        }
-        function _createNew(plugins, startAt) {
-            if (plugins === void 0) { plugins = null; }
-            if (isArray(plugins)) {
-                plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt);
-            }
-            return createProcessTelemetryUnloadContext(plugins || context[_DYN_GET_NEXT ](), core, startAt);
-        }
-        context[_DYN_PROCESS_NEXT ] = _processNext;
-        context[_DYN_CREATE_NEW ] = _createNew;
-        return context;
+    function getGblPerfMgr() {
+        return _defaultPerfManager;
     }
-    function createProcessTelemetryUpdateContext(telemetryChain, core, startAt) {
-        var config = createDynamicConfig(core[_DYN_CONFIG ]);
-        var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
-        var context = internalContext.ctx;
-        function _processNext(updateState) {
-            return context.iterate(function (plugin) {
-                if (isFunction(plugin[_DYN_UPDATE ])) {
-                    plugin[_DYN_UPDATE ](context, updateState);
-                }
-            });
+
+    var Undefined = strShimUndefined;
+    function newGuid() {
+        var uuid = generateW3CId();
+        return strSubstring(uuid, 0, 8) + "-" + strSubstring(uuid, 8, 12) + "-" + strSubstring(uuid, 12, 16) + "-" + strSubstring(uuid, 16, 20) + "-" + strSubstring(uuid, 20);
+    }
+    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];
         }
-        function _createNew(plugins, startAt) {
-            if (plugins === void 0) { plugins = null; }
-            if (isArray(plugins)) {
-                plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt);
-            }
-            return createProcessTelemetryUpdateContext(plugins || context[_DYN_GET_NEXT ](), core, startAt);
+        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 TRACE_PARENT_REGEX = /^([\da-f]{2})-([\da-f]{32})-([\da-f]{16})-([\da-f]{2})(-[^\s]{1,64})?$/i;
+    var DEFAULT_VERSION = "00";
+    var INVALID_VERSION = "ff";
+    var INVALID_TRACE_ID = "00000000000000000000000000000000";
+    var INVALID_SPAN_ID = "0000000000000000";
+    var SAMPLED_FLAG = 0x01;
+    function _isValid(value, len, invalidValue) {
+        if (value && value[_DYN_LENGTH ] === len && value !== invalidValue) {
+            return !!value.match(/^[\da-f]*$/i);
         }
-        context[_DYN_PROCESS_NEXT ] = _processNext;
-        context[_DYN_CREATE_NEW ] = _createNew;
-        return context;
+        return false;
     }
-    function createTelemetryProxyChain(plugins, config, core, startAt) {
-        var firstProxy = null;
-        var add = startAt ? false : true;
-        if (isArray(plugins) && plugins[_DYN_LENGTH ] > 0) {
-            var lastProxy_1 = null;
-            arrForEach(plugins, function (thePlugin) {
-                if (!add && startAt === thePlugin) {
-                    add = true;
-                }
-                if (add && thePlugin && isFunction(thePlugin[STR_PROCESS_TELEMETRY ])) {
-                    var newProxy = createTelemetryPluginProxy(thePlugin, config, core);
-                    if (!firstProxy) {
-                        firstProxy = newProxy;
-                    }
-                    if (lastProxy_1) {
-                        lastProxy_1._setNext(newProxy);
-                    }
-                    lastProxy_1 = newProxy;
-                }
-            });
+    function _formatValue(value, len, defValue) {
+        if (_isValid(value, len)) {
+            return value;
         }
-        if (startAt && !firstProxy) {
-            return createTelemetryProxyChain([startAt], config, core);
+        return defValue;
+    }
+    function _formatFlags(value) {
+        if (isNaN(value) || value < 0 || value > 255) {
+            value = 0x01;
         }
-        return firstProxy;
+        var result = value.toString(16);
+        while (result[_DYN_LENGTH ] < 2) {
+            result = "0" + result;
+        }
+        return result;
     }
-    function createTelemetryPluginProxy(plugin, config, core) {
-        var nextProxy = null;
-        var hasProcessTelemetry = isFunction(plugin[STR_PROCESS_TELEMETRY ]);
-        var hasSetNext = isFunction(plugin[_DYN_SET_NEXT_PLUGIN ]);
-        var chainId;
-        if (plugin) {
-            chainId = plugin[_DYN_IDENTIFIER ] + "-" + plugin[STR_PRIORITY ] + "-" + _chainId++;
+    function createTraceParent(traceId, spanId, flags, version) {
+        var _a;
+        return _a = {},
+            _a[_DYN_VERSION ] = _isValid(version, 2, INVALID_VERSION) ? version : DEFAULT_VERSION,
+            _a[_DYN_TRACE_ID ] = isValidTraceId(traceId) ? traceId : generateW3CId(),
+            _a[_DYN_SPAN_ID ] = isValidSpanId(spanId) ? spanId : strLeft(generateW3CId(), 16),
+            _a.traceFlags = flags >= 0 && flags <= 0xFF ? flags : 1,
+            _a;
+    }
+    function parseTraceParent(value) {
+        var _a;
+        if (!value) {
+            return null;
         }
-        else {
-            chainId = "Unknown-0-" + _chainId++;
+        if (isArray(value)) {
+            value = value[0] || "";
         }
-        var proxyChain = {
-            getPlugin: function () {
-                return plugin;
-            },
-            getNext: function () {
-                return nextProxy;
-            },
-            processTelemetry: _processTelemetry,
-            unload: _unloadPlugin,
-            update: _updatePlugin,
-            _id: chainId,
-            _setNext: function (nextPlugin) {
-                nextProxy = nextPlugin;
-            }
-        };
-        function _getTelCtx() {
-            var itemCtx;
-            if (plugin && isFunction(plugin[strGetTelCtx])) {
-                itemCtx = plugin[strGetTelCtx]();
-            }
-            if (!itemCtx) {
-                itemCtx = createProcessTelemetryContext(proxyChain, config, core);
-            }
-            return itemCtx;
+        if (!value || !isString(value) || value[_DYN_LENGTH ] > 8192) {
+            return null;
         }
-        function _processChain(itemCtx, processPluginFn, name, details, isAsync) {
-            var hasRun = false;
-            var identifier = plugin ? plugin[_DYN_IDENTIFIER ] : strTelemetryPluginChain;
-            var hasRunContext = itemCtx[strHasRunFlags];
-            if (!hasRunContext) {
-                hasRunContext = itemCtx[strHasRunFlags] = {};
-            }
-            itemCtx.setNext(nextProxy);
-            if (plugin) {
-                doPerf(itemCtx[STR_CORE ](), function () { return identifier + ":" + name; }, function () {
-                    hasRunContext[chainId] = true;
-                    try {
-                        var nextId = nextProxy ? nextProxy._id : STR_EMPTY;
-                        if (nextId) {
-                            hasRunContext[nextId] = false;
-                        }
-                        hasRun = processPluginFn(itemCtx);
-                    }
-                    catch (error) {
-                        var hasNextRun = nextProxy ? hasRunContext[nextProxy._id] : true;
-                        if (hasNextRun) {
-                            hasRun = true;
-                        }
-                        if (!nextProxy || !hasNextRun) {
-                            _throwInternal(itemCtx[_DYN_DIAG_LOG ](), 1 , 73 , "Plugin [" + identifier + "] failed during " + name + " - " + dumpObj(error) + ", run flags: " + dumpObj(hasRunContext));
-                        }
-                    }
-                }, details, isAsync);
-            }
-            return hasRun;
+        var match = TRACE_PARENT_REGEX.exec(strTrim(value));
+        if (!match ||
+            match[1] === INVALID_VERSION ||
+            match[2] === INVALID_TRACE_ID ||
+            match[3] === INVALID_SPAN_ID) {
+            return null;
         }
-        function _processTelemetry(env, itemCtx) {
-            itemCtx = itemCtx || _getTelCtx();
-            function _callProcessTelemetry(itemCtx) {
-                if (!plugin || !hasProcessTelemetry) {
-                    return false;
-                }
-                var pluginState = _getPluginState(plugin);
-                if (pluginState[_DYN_TEARDOWN ] || pluginState[STR_DISABLED]) {
-                    return false;
-                }
-                if (hasSetNext) {
-                    plugin[_DYN_SET_NEXT_PLUGIN ](nextProxy);
-                }
-                plugin[STR_PROCESS_TELEMETRY ](env, itemCtx);
-                return true;
-            }
-            if (!_processChain(itemCtx, _callProcessTelemetry, "processTelemetry", function () { return ({ item: env }); }, !(env.sync))) {
-                itemCtx[_DYN_PROCESS_NEXT ](env);
-            }
+        return _a = {},
+            _a[_DYN_VERSION ] = (match[1] || STR_EMPTY)[_DYN_TO_LOWER_CASE ](),
+            _a.traceId = (match[2] || STR_EMPTY)[_DYN_TO_LOWER_CASE ](),
+            _a.spanId = (match[3] || STR_EMPTY)[_DYN_TO_LOWER_CASE ](),
+            _a[_DYN_TRACE_FLAGS ] = parseInt(match[4], 16),
+            _a;
+    }
+    function isValidTraceId(value) {
+        return _isValid(value, 32, INVALID_TRACE_ID);
+    }
+    function isValidSpanId(value) {
+        return _isValid(value, 16, INVALID_SPAN_ID);
+    }
+    function isValidTraceParent(value) {
+        if (!value ||
+            !_isValid(value[_DYN_VERSION ], 2, INVALID_VERSION) ||
+            !_isValid(value[_DYN_TRACE_ID ], 32, INVALID_TRACE_ID) ||
+            !_isValid(value[_DYN_SPAN_ID ], 16, INVALID_SPAN_ID) ||
+            !_isValid(_formatFlags(value[_DYN_TRACE_FLAGS ]), 2)) {
+            return false;
         }
-        function _unloadPlugin(unloadCtx, unloadState) {
-            function _callTeardown() {
-                var hasRun = false;
-                if (plugin) {
-                    var pluginState = _getPluginState(plugin);
-                    var pluginCore = plugin[STR_CORE] || pluginState[STR_CORE ];
-                    if (plugin && (!pluginCore || pluginCore === unloadCtx.core()) && !pluginState[_DYN_TEARDOWN ]) {
-                        pluginState[STR_CORE ] = null;
-                        pluginState[_DYN_TEARDOWN ] = true;
-                        pluginState[_DYN_IS_INITIALIZED ] = false;
-                        if (plugin[_DYN_TEARDOWN ] && plugin[_DYN_TEARDOWN ](unloadCtx, unloadState) === true) {
-                            hasRun = true;
-                        }
-                    }
-                }
-                return hasRun;
-            }
-            if (!_processChain(unloadCtx, _callTeardown, "unload", function () { }, unloadState[_DYN_IS_ASYNC ])) {
-                unloadCtx[_DYN_PROCESS_NEXT ](unloadState);
-            }
+        return true;
+    }
+    function isSampledFlag(value) {
+        if (isValidTraceParent(value)) {
+            return (value[_DYN_TRACE_FLAGS ] & SAMPLED_FLAG) === SAMPLED_FLAG;
         }
-        function _updatePlugin(updateCtx, updateState) {
-            function _callUpdate() {
-                var hasRun = false;
-                if (plugin) {
-                    var pluginState = _getPluginState(plugin);
-                    var pluginCore = plugin[STR_CORE] || pluginState[STR_CORE ];
-                    if (plugin && (!pluginCore || pluginCore === updateCtx.core()) && !pluginState[_DYN_TEARDOWN ]) {
-                        if (plugin[_DYN_UPDATE ] && plugin[_DYN_UPDATE ](updateCtx, updateState) === true) {
-                            hasRun = true;
-                        }
-                    }
-                }
-                return hasRun;
+        return false;
+    }
+    function formatTraceParent(value) {
+        if (value) {
+            var flags = _formatFlags(value[_DYN_TRACE_FLAGS ]);
+            if (!_isValid(flags, 2)) {
+                flags = "01";
             }
-            if (!_processChain(updateCtx, _callUpdate, "update", function () { }, false)) {
-                updateCtx[_DYN_PROCESS_NEXT ](updateState);
+            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 objFreeze(proxyChain);
+        return "";
     }
-    var ProcessTelemetryContext = /** @class */ (function () {
-        function ProcessTelemetryContext(pluginChain, config, core, startAt) {
-            var _self = this;
-            var context = createProcessTelemetryContext(pluginChain, config, core, startAt);
-            proxyFunctions(_self, context, objKeys(context));
+    function findW3cTraceParent() {
+        var name = "traceparent";
+        var traceParent = parseTraceParent(findMetaTag(name));
+        if (!traceParent) {
+            traceParent = parseTraceParent(findNamedServerTiming(name));
         }
-        return ProcessTelemetryContext;
-    }());
+        return traceParent;
+    }
 
-    var ChannelControllerPriority = 500;
-    var ChannelValidationMessage = "Channel has invalid priority - ";
-    function _addChannelQueue(channelQueue, queue, core) {
-        if (queue && isArray(queue) && queue[_DYN_LENGTH ] > 0) {
-            queue = queue.sort(function (a, b) {
-                return a[STR_PRIORITY ] - b[STR_PRIORITY ];
-            });
-            arrForEach(queue, function (queueItem) {
-                if (queueItem[STR_PRIORITY ] < ChannelControllerPriority) {
-                    throwError(ChannelValidationMessage + queueItem[_DYN_IDENTIFIER ]);
+    var pluginStateData = createElmNodeData("plugin");
+    function _getPluginState(plugin) {
+        return pluginStateData.get(plugin, "state", {}, true);
+    }
+    function initializePlugins(processContext, extensions) {
+        var initPlugins = [];
+        var lastPlugin = null;
+        var proxy = processContext[_DYN_GET_NEXT ]();
+        var pluginState;
+        while (proxy) {
+            var thePlugin = proxy[_DYN_GET_PLUGIN ]();
+            if (thePlugin) {
+                if (lastPlugin && lastPlugin[_DYN_SET_NEXT_PLUGIN ] && thePlugin[STR_PROCESS_TELEMETRY ]) {
+                    lastPlugin[_DYN_SET_NEXT_PLUGIN ](thePlugin);
+                }
+                var isInitialized = false;
+                if (isFunction(thePlugin[_DYN_IS_INITIALIZED ])) {
+                    isInitialized = thePlugin[_DYN_IS_INITIALIZED ]();
+                }
+                else {
+                    pluginState = _getPluginState(thePlugin);
+                    isInitialized = pluginState[_DYN_IS_INITIALIZED ];
                 }
-            });
-            channelQueue[_DYN_PUSH ]({
-                queue: objFreeze(queue),
-                chain: createTelemetryProxyChain(queue, core[_DYN_CONFIG ], core)
-            });
+                if (!isInitialized) {
+                    initPlugins[_DYN_PUSH ](thePlugin);
+                }
+                lastPlugin = thePlugin;
+                proxy = proxy[_DYN_GET_NEXT ]();
+            }
         }
+        arrForEach(initPlugins, function (thePlugin) {
+            var core = processContext[STR_CORE ]();
+            thePlugin[_DYN_INITIALIZE ](processContext.getCfg(), core, extensions, processContext[_DYN_GET_NEXT ]());
+            pluginState = _getPluginState(thePlugin);
+            if (!thePlugin[STR_CORE] && !pluginState[STR_CORE]) {
+                pluginState[STR_CORE] = core;
+            }
+            pluginState[_DYN_IS_INITIALIZED ] = true;
+            delete pluginState[_DYN_TEARDOWN ];
+        });
     }
-    function createChannelControllerPlugin(channelQueue, core) {
-        function _getTelCtx() {
-            return createProcessTelemetryContext(null, core[_DYN_CONFIG ], core, null);
-        }
-        function _processChannelQueue(theChannels, itemCtx, processFn, onComplete) {
-            var waiting = theChannels ? (theChannels[_DYN_LENGTH ] + 1) : 1;
-            function _runChainOnComplete() {
-                waiting--;
-                if (waiting === 0) {
-                    onComplete && onComplete();
-                    onComplete = null;
+    function sortPlugins(plugins) {
+        return plugins.sort(function (extA, extB) {
+            var result = 0;
+            if (extB) {
+                var bHasProcess = extB[STR_PROCESS_TELEMETRY];
+                if (extA[STR_PROCESS_TELEMETRY]) {
+                    result = bHasProcess ? extA[STR_PRIORITY] - extB[STR_PRIORITY] : 1;
+                }
+                else if (bHasProcess) {
+                    result = -1;
                 }
             }
-            if (waiting > 0) {
-                arrForEach(theChannels, function (channels) {
-                    if (channels && channels.queue[_DYN_LENGTH ] > 0) {
-                        var channelChain = channels.chain;
-                        var chainCtx = itemCtx[_DYN_CREATE_NEW ](channelChain);
-                        chainCtx[_DYN_ON_COMPLETE ](_runChainOnComplete);
-                        processFn(chainCtx);
-                    }
-                    else {
-                        waiting--;
-                    }
-                });
+            else {
+                result = extA ? 1 : -1;
             }
-            _runChainOnComplete();
-        }
-        function _doUpdate(updateCtx, updateState) {
-            var theUpdateState = updateState || {
-                reason: 0
-            };
-            _processChannelQueue(channelQueue, updateCtx, function (chainCtx) {
-                chainCtx[_DYN_PROCESS_NEXT ](theUpdateState);
-            }, function () {
-                updateCtx[_DYN_PROCESS_NEXT ](theUpdateState);
-            });
-            return true;
-        }
-        function _doTeardown(unloadCtx, unloadState) {
-            var theUnloadState = unloadState || {
-                reason: 0 ,
-                isAsync: false
-            };
-            _processChannelQueue(channelQueue, unloadCtx, function (chainCtx) {
-                chainCtx[_DYN_PROCESS_NEXT ](theUnloadState);
-            }, function () {
-                unloadCtx[_DYN_PROCESS_NEXT ](theUnloadState);
-                isInitialized = false;
-            });
-            return true;
-        }
-        function _getChannel(pluginIdentifier) {
-            var thePlugin = null;
-            if (channelQueue && channelQueue[_DYN_LENGTH ] > 0) {
-                arrForEach(channelQueue, function (channels) {
-                    if (channels && channels.queue[_DYN_LENGTH ] > 0) {
-                        arrForEach(channels.queue, function (ext) {
-                            if (ext[_DYN_IDENTIFIER ] === pluginIdentifier) {
-                                thePlugin = ext;
-                                return -1;
-                            }
-                        });
-                        if (thePlugin) {
-                            return -1;
+            return result;
+        });
+    }
+    function unloadComponents(components, unloadCtx, unloadState, asyncCallback) {
+        var idx = 0;
+        function _doUnload() {
+            while (idx < components[_DYN_LENGTH ]) {
+                var component = components[idx++];
+                if (component) {
+                    var func = component._doUnload || component[_DYN__DO_TEARDOWN ];
+                    if (isFunction(func)) {
+                        if (func[_DYN_CALL ](component, unloadCtx, unloadState, _doUnload) === true) {
+                            return true;
                         }
                     }
-                });
+                }
             }
-            return thePlugin;
         }
-        var isInitialized = false;
-        var channelController = {
-            identifier: "ChannelControllerPlugin",
-            priority: ChannelControllerPriority,
-            initialize: function (config, core, extensions, pluginChain) {
-                isInitialized = true;
-                arrForEach(channelQueue, function (channels) {
-                    if (channels && channels.queue[_DYN_LENGTH ] > 0) {
-                        initializePlugins(createProcessTelemetryContext(channels.chain, config, core), extensions);
-                    }
-                });
+        return _doUnload();
+    }
+    function createDistributedTraceContext(parentCtx) {
+        var trace = {};
+        return {
+            getName: function () {
+                return trace[_DYN_NAME ];
             },
-            isInitialized: function () {
-                return isInitialized;
+            setName: function (newValue) {
+                parentCtx && parentCtx.setName(newValue);
+                trace[_DYN_NAME ] = newValue;
             },
-            processTelemetry: function (item, itemCtx) {
-                _processChannelQueue(channelQueue, itemCtx || _getTelCtx(), function (chainCtx) {
-                    chainCtx[_DYN_PROCESS_NEXT ](item);
-                }, function () {
-                    itemCtx[_DYN_PROCESS_NEXT ](item);
-                });
+            getTraceId: function () {
+                return trace[_DYN_TRACE_ID ];
             },
-            update: _doUpdate,
-            pause: function () {
-                _processChannelQueue(channelQueue, _getTelCtx(), function (chainCtx) {
-                    chainCtx.iterate(function (plugin) {
-                        plugin.pause && plugin.pause();
-                    });
-                }, null);
+            setTraceId: function (newValue) {
+                parentCtx && parentCtx.setTraceId(newValue);
+                if (isValidTraceId(newValue)) {
+                    trace[_DYN_TRACE_ID ] = newValue;
+                }
             },
-            resume: function () {
-                _processChannelQueue(channelQueue, _getTelCtx(), function (chainCtx) {
-                    chainCtx.iterate(function (plugin) {
-                        plugin.resume && plugin.resume();
-                    });
-                }, null);
+            getSpanId: function () {
+                return trace[_DYN_SPAN_ID ];
             },
-            teardown: _doTeardown,
-            getChannel: _getChannel,
-            flush: function (isAsync, callBack, sendReason, cbTimeout) {
-                var waiting = 1;
-                var doneIterating = false;
-                var cbTimer = null;
-                cbTimeout = cbTimeout || 5000;
-                function doCallback() {
-                    waiting--;
-                    if (doneIterating && waiting === 0) {
-                        cbTimer && cbTimer[_DYN_CANCEL ]();
-                        cbTimer = null;
-                        callBack && callBack(doneIterating);
-                        callBack = null;
-                    }
-                }
-                _processChannelQueue(channelQueue, _getTelCtx(), function (chainCtx) {
-                    chainCtx.iterate(function (plugin) {
-                        if (plugin[_DYN_FLUSH ]) {
-                            waiting++;
-                            var handled_1 = false;
-                            if (!plugin[_DYN_FLUSH ](isAsync, function () {
-                                handled_1 = true;
-                                doCallback();
-                            }, sendReason)) {
-                                if (!handled_1) {
-                                    if (isAsync && cbTimer == null) {
-                                        cbTimer = scheduleTimeout(function () {
-                                            cbTimer = null;
-                                            doCallback();
-                                        }, cbTimeout);
-                                    }
-                                    else {
-                                        doCallback();
-                                    }
-                                }
-                            }
-                        }
-                    });
-                }, function () {
-                    doneIterating = true;
-                    doCallback();
-                });
-                return true;
+            setSpanId: function (newValue) {
+                parentCtx && parentCtx.setSpanId(newValue);
+                if (isValidSpanId(newValue)) {
+                    trace[_DYN_SPAN_ID ] = newValue;
+                }
             },
-            _setQueue: function (queue) {
-                channelQueue = queue;
+            getTraceFlags: function () {
+                return trace[_DYN_TRACE_FLAGS ];
+            },
+            setTraceFlags: function (newTraceFlags) {
+                parentCtx && parentCtx.setTraceFlags(newTraceFlags);
+                trace[_DYN_TRACE_FLAGS ] = newTraceFlags;
             }
         };
-        return channelController;
-    }
-    function createChannelQueues(channels, extensions, core) {
-        var channelQueue = [];
-        if (channels) {
-            arrForEach(channels, function (queue) { return _addChannelQueue(channelQueue, queue, core); });
-        }
-        if (extensions) {
-            var extensionQueue_1 = [];
-            arrForEach(extensions, function (plugin) {
-                if (plugin[STR_PRIORITY ] > ChannelControllerPriority) {
-                    extensionQueue_1[_DYN_PUSH ](plugin);
-                }
-            });
-            _addChannelQueue(channelQueue, extensionQueue_1, core);
-        }
-        return channelQueue;
     }
 
-    var _a$2, _b;
-    var strToGMTString = "toGMTString";
-    var strToUTCString = "toUTCString";
-    var strCookie = "cookie";
-    var strExpires = "expires";
-    var strIsCookieUseDisabled = "isCookieUseDisabled";
-    var strDisableCookiesUsage = "disableCookiesUsage";
-    var strConfigCookieMgr = "_ckMgr";
-    var _supportsCookies = null;
-    var _allowUaSameSite = null;
-    var _parsedCookieValue = null;
-    var _doc = getDocument();
-    var _cookieCache = {};
-    var _globalCookieConfig = {};
-    var defaultConfig$1 = objDeepFreeze((_a$2 = {},
-        _a$2[STR_DOMAIN] = { fb: "cookieDomain", dfVal: isNotNullOrUndefined },
-        _a$2.path = { fb: "cookiePath", dfVal: isNotNullOrUndefined },
-        _a$2.enabled = UNDEFINED_VALUE,
-        _a$2));
-    var rootDefaultConfig = (_b = {
-            cookieCfg: {},
-            cookieDomain: UNDEFINED_VALUE,
-            cookiePath: UNDEFINED_VALUE
-        },
-        _b[strDisableCookiesUsage] = UNDEFINED_VALUE,
-        _b);
-    function _gblCookieMgr(config, logger) {
-        var inst = createCookieMgr[strConfigCookieMgr] || _globalCookieConfig[strConfigCookieMgr];
-        if (!inst) {
-            inst = createCookieMgr[strConfigCookieMgr] = createCookieMgr(config, logger);
-            _globalCookieConfig[strConfigCookieMgr] = inst;
-        }
-        return inst;
-    }
-    function _isMgrEnabled(cookieMgr) {
-        if (cookieMgr) {
-            return cookieMgr.isEnabled();
-        }
-        return true;
-    }
-    function _isIgnoredCookie(cookieMgrCfg, name) {
-        if (name && cookieMgrCfg && isArray(cookieMgrCfg.ignoreCookies)) {
-            return arrIndexOf(cookieMgrCfg.ignoreCookies, name) !== -1;
-        }
-        return false;
-    }
-    function _isBlockedCookie(cookieMgrCfg, name) {
-        if (name && cookieMgrCfg && isArray(cookieMgrCfg.blockedCookies)) {
-            if (arrIndexOf(cookieMgrCfg.blockedCookies, name) !== -1) {
-                return true;
+    var strTelemetryPluginChain = "TelemetryPluginChain";
+    var strHasRunFlags = "_hasRun";
+    var strGetTelCtx = "_getTelCtx";
+    var _chainId = 0;
+    function _getNextProxyStart(proxy, core, startAt) {
+        while (proxy) {
+            if (proxy[_DYN_GET_PLUGIN ]() === startAt) {
+                return proxy;
             }
+            proxy = proxy[_DYN_GET_NEXT ]();
         }
-        return _isIgnoredCookie(cookieMgrCfg, name);
+        return createTelemetryProxyChain([startAt], core.config || {}, core);
     }
-    function safeGetCookieMgr(core, config) {
-        var cookieMgr;
-        if (core) {
-            cookieMgr = core.getCookieMgr();
+    function _createInternalContext(telemetryChain, dynamicHandler, core, startAt) {
+        var _nextProxy = null;
+        var _onComplete = [];
+        if (!dynamicHandler) {
+            dynamicHandler = createDynamicConfig({}, null, core[_DYN_LOGGER ]);
         }
-        else if (config) {
-            var cookieCfg = config.cookieCfg;
-            if (cookieCfg && cookieCfg[strConfigCookieMgr]) {
-                cookieMgr = cookieCfg[strConfigCookieMgr];
+        if (startAt !== null) {
+            _nextProxy = startAt ? _getNextProxyStart(telemetryChain, core, startAt) : telemetryChain;
+        }
+        var context = {
+            _next: _moveNext,
+            ctx: {
+                core: function () {
+                    return core;
+                },
+                diagLog: function () {
+                    return safeGetLogger(core, dynamicHandler.cfg);
+                },
+                getCfg: function () {
+                    return dynamicHandler.cfg;
+                },
+                getExtCfg: _resolveExtCfg,
+                getConfig: _getConfig,
+                hasNext: function () {
+                    return !!_nextProxy;
+                },
+                getNext: function () {
+                    return _nextProxy;
+                },
+                setNext: function (nextPlugin) {
+                    _nextProxy = nextPlugin;
+                },
+                iterate: _iterateChain,
+                onComplete: _addOnComplete
             }
-            else {
-                cookieMgr = createCookieMgr(config);
+        };
+        function _addOnComplete(onComplete, that) {
+            var args = [];
+            for (var _i = 2; _i < arguments.length; _i++) {
+                args[_i - 2] = arguments[_i];
             }
-        }
-        if (!cookieMgr) {
-            cookieMgr = _gblCookieMgr(config, (core || {})[_DYN_LOGGER ]);
-        }
-        return cookieMgr;
-    }
-    function createCookieMgr(rootConfig, logger) {
-        var cookieMgrConfig;
-        var _path;
-        var _domain;
-        var _enabled;
-        var _getCookieFn;
-        var _setCookieFn;
-        var _delCookieFn;
-        rootConfig = createDynamicConfig(rootConfig || _globalCookieConfig, null, logger).cfg;
-        onConfigChange(rootConfig, function (details) {
-            details[_DYN_SET_DF ](details.cfg, rootDefaultConfig);
-            cookieMgrConfig = details[_DYN_SET_DF ](details.cfg.cookieCfg, defaultConfig$1);
-            var isEnabled = cookieMgrConfig.enabled;
-            if (isNullOrUndefined(isEnabled)) {
-                var cookieEnabled = void 0;
-                if (!isUndefined(rootConfig[strIsCookieUseDisabled])) {
-                    cookieEnabled = !rootConfig[strIsCookieUseDisabled];
-                }
-                if (!isUndefined(rootConfig[strDisableCookiesUsage])) {
-                    cookieEnabled = !rootConfig[strDisableCookiesUsage];
-                }
-                isEnabled = cookieEnabled;
+            if (onComplete) {
+                _onComplete[_DYN_PUSH ]({
+                    func: onComplete,
+                    self: !isUndefined(that) ? that : context.ctx,
+                    args: args
+                });
             }
-            _path = cookieMgrConfig[STR_PATH ] || "/";
-            _domain = cookieMgrConfig[STR_DOMAIN ];
-            _enabled = isEnabled !== false;
-            _getCookieFn = cookieMgrConfig.getCookie || _getCookieValue;
-            _setCookieFn = cookieMgrConfig.setCookie || _setCookieValue;
-            _delCookieFn = cookieMgrConfig.delCookie || _setCookieValue;
-        }, logger);
-        var cookieMgr = {
-            isEnabled: function () {
-                var enabled = _enabled && areCookiesSupported(logger);
-                var gblManager = _globalCookieConfig[strConfigCookieMgr];
-                if (enabled && gblManager && cookieMgr !== gblManager) {
-                    enabled = _isMgrEnabled(gblManager);
-                }
-                return enabled;
-            },
-            setEnabled: function (value) {
-                _enabled = value !== false;
-            },
-            set: function (name, value, maxAgeSec, domain, path) {
-                var result = false;
-                if (_isMgrEnabled(cookieMgr) && !_isBlockedCookie(cookieMgrConfig, name)) {
-                    var values = {};
-                    var theValue = strTrim(value || STR_EMPTY);
-                    var idx = strIndexOf(theValue, ";");
-                    if (idx !== -1) {
-                        theValue = strTrim(strLeft(value, idx));
-                        values = _extractParts(strSubstring(value, idx + 1));
-                    }
-                    setValue(values, STR_DOMAIN, domain || _domain, isTruthy, isUndefined);
-                    if (!isNullOrUndefined(maxAgeSec)) {
-                        var _isIE = isIE();
-                        if (isUndefined(values[strExpires])) {
-                            var nowMs = utcNow();
-                            var expireMs = nowMs + (maxAgeSec * 1000);
-                            if (expireMs > 0) {
-                                var expiry = new Date();
-                                expiry.setTime(expireMs);
-                                setValue(values, strExpires, _formatDate(expiry, !_isIE ? strToUTCString : strToGMTString) || _formatDate(expiry, _isIE ? strToGMTString : strToUTCString) || STR_EMPTY, isTruthy);
-                            }
-                        }
-                        if (!_isIE) {
-                            setValue(values, "max-age", STR_EMPTY + maxAgeSec, null, isUndefined);
-                        }
-                    }
-                    var location_1 = getLocation();
-                    if (location_1 && location_1.protocol === "https:") {
-                        setValue(values, "secure", null, null, isUndefined);
-                        if (_allowUaSameSite === null) {
-                            _allowUaSameSite = !uaDisallowsSameSiteNone((getNavigator() || {})[_DYN_USER_AGENT ]);
+        }
+        function _moveNext() {
+            var nextProxy = _nextProxy;
+            _nextProxy = nextProxy ? nextProxy[_DYN_GET_NEXT ]() : null;
+            if (!nextProxy) {
+                var onComplete = _onComplete;
+                if (onComplete && onComplete[_DYN_LENGTH ] > 0) {
+                    arrForEach(onComplete, function (completeDetails) {
+                        try {
+                            completeDetails.func[_DYN_CALL ](completeDetails.self, completeDetails.args);
                         }
-                        if (_allowUaSameSite) {
-                            setValue(values, "SameSite", "None", null, isUndefined);
+                        catch (e) {
+                            _throwInternal(core[_DYN_LOGGER ], 2 , 73 , "Unexpected Exception during onComplete - " + dumpObj(e));
                         }
-                    }
-                    setValue(values, STR_PATH, path || _path, null, isUndefined);
-                    _setCookieFn(name, _formatCookieValue(theValue, values));
-                    result = true;
-                }
-                return result;
-            },
-            get: function (name) {
-                var value = STR_EMPTY;
-                if (_isMgrEnabled(cookieMgr) && !_isIgnoredCookie(cookieMgrConfig, name)) {
-                    value = _getCookieFn(name);
+                    });
+                    _onComplete = [];
                 }
-                return value;
-            },
-            del: function (name, path) {
-                var result = false;
-                if (_isMgrEnabled(cookieMgr)) {
-                    result = cookieMgr.purge(name, path);
+            }
+            return nextProxy;
+        }
+        function _getExtCfg(identifier, createIfMissing) {
+            var idCfg = null;
+            var cfg = dynamicHandler.cfg;
+            if (cfg && identifier) {
+                var extCfg = cfg[STR_EXTENSION_CONFIG ];
+                if (!extCfg && createIfMissing) {
+                    extCfg = {};
                 }
-                return result;
-            },
-            purge: function (name, path) {
-                var _a;
-                var result = false;
-                if (areCookiesSupported(logger)) {
-                    var values = (_a = {},
-                        _a[STR_PATH] = path ? path : "/",
-                        _a[strExpires] = "Thu, 01 Jan 1970 00:00:01 GMT",
-                        _a);
-                    if (!isIE()) {
-                        values["max-age"] = "0";
+                dynamicHandler.set(cfg, STR_EXTENSION_CONFIG, extCfg);
+                extCfg = cfg[STR_EXTENSION_CONFIG ];
+                if (extCfg) {
+                    idCfg = extCfg[identifier];
+                    if (!idCfg && createIfMissing) {
+                        idCfg = {};
                     }
-                    _delCookieFn(name, _formatCookieValue(STR_EMPTY, values));
-                    result = true;
+                    dynamicHandler.set(extCfg, identifier, idCfg);
+                    idCfg = extCfg[identifier];
                 }
-                return result;
             }
-        };
-        cookieMgr[strConfigCookieMgr] = cookieMgr;
-        return cookieMgr;
-    }
-    function areCookiesSupported(logger) {
-        if (_supportsCookies === null) {
-            _supportsCookies = false;
-            try {
-                var doc = _doc || {};
-                _supportsCookies = doc[strCookie] !== undefined;
+            return idCfg;
+        }
+        function _resolveExtCfg(identifier, defaultValues) {
+            var newConfig = _getExtCfg(identifier, true);
+            if (defaultValues) {
+                objForEachKey(defaultValues, function (field, defaultValue) {
+                    if (isNullOrUndefined(newConfig[field])) {
+                        var cfgValue = dynamicHandler.cfg[field];
+                        if (cfgValue || !isNullOrUndefined(cfgValue)) {
+                            newConfig[field] = cfgValue;
+                        }
+                    }
+                    _applyDefaultValue(dynamicHandler, newConfig, field, defaultValue);
+                });
             }
-            catch (e) {
-                _throwInternal(logger, 2 , 68 , "Cannot access document.cookie - " + getExceptionName(e), { exception: dumpObj(e) });
+            return dynamicHandler[_DYN_SET_DF ](newConfig, defaultValues);
+        }
+        function _getConfig(identifier, field, defaultValue) {
+            if (defaultValue === void 0) { defaultValue = false; }
+            var theValue;
+            var extConfig = _getExtCfg(identifier, false);
+            var rootConfig = dynamicHandler.cfg;
+            if (extConfig && (extConfig[field] || !isNullOrUndefined(extConfig[field]))) {
+                theValue = extConfig[field];
             }
+            else if (rootConfig[field] || !isNullOrUndefined(rootConfig[field])) {
+                theValue = rootConfig[field];
+            }
+            return (theValue || !isNullOrUndefined(theValue)) ? theValue : defaultValue;
         }
-        return _supportsCookies;
-    }
-    function _extractParts(theValue) {
-        var values = {};
-        if (theValue && theValue[_DYN_LENGTH ]) {
-            var parts = strTrim(theValue)[_DYN_SPLIT ](";");
-            arrForEach(parts, function (thePart) {
-                thePart = strTrim(thePart || STR_EMPTY);
-                if (thePart) {
-                    var idx = strIndexOf(thePart, "=");
-                    if (idx === -1) {
-                        values[thePart] = null;
-                    }
-                    else {
-                        values[strTrim(strLeft(thePart, idx))] = strTrim(strSubstring(thePart, idx + 1));
-                    }
+        function _iterateChain(cb) {
+            var nextPlugin;
+            while (!!(nextPlugin = context._next())) {
+                var plugin = nextPlugin[_DYN_GET_PLUGIN ]();
+                if (plugin) {
+                    cb(plugin);
                 }
-            });
+            }
         }
-        return values;
+        return context;
     }
-    function _formatDate(theDate, func) {
-        if (isFunction(theDate[func])) {
-            return theDate[func]();
+    function createProcessTelemetryContext(telemetryChain, cfg, core, startAt) {
+        var config = createDynamicConfig(cfg);
+        var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
+        var context = internalContext.ctx;
+        function _processNext(env) {
+            var nextPlugin = internalContext._next();
+            if (nextPlugin) {
+                nextPlugin[STR_PROCESS_TELEMETRY ](env, context);
+            }
+            return !nextPlugin;
         }
-        return null;
-    }
-    function _formatCookieValue(value, values) {
-        var cookieValue = value || STR_EMPTY;
-        objForEachKey(values, function (name, theValue) {
-            cookieValue += "; " + name + (!isNullOrUndefined(theValue) ? "=" + theValue : STR_EMPTY);
-        });
-        return cookieValue;
-    }
-    function _getCookieValue(name) {
-        var cookieValue = STR_EMPTY;
-        if (_doc) {
-            var theCookie = _doc[strCookie] || STR_EMPTY;
-            if (_parsedCookieValue !== theCookie) {
-                _cookieCache = _extractParts(theCookie);
-                _parsedCookieValue = theCookie;
+        function _createNew(plugins, startAt) {
+            if (plugins === void 0) { plugins = null; }
+            if (isArray(plugins)) {
+                plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt);
             }
-            cookieValue = strTrim(_cookieCache[name] || STR_EMPTY);
+            return createProcessTelemetryContext(plugins || context[_DYN_GET_NEXT ](), config.cfg, core, startAt);
         }
-        return cookieValue;
+        context[_DYN_PROCESS_NEXT ] = _processNext;
+        context[_DYN_CREATE_NEW ] = _createNew;
+        return context;
     }
-    function _setCookieValue(name, cookieValue) {
-        if (_doc) {
-            _doc[strCookie] = name + "=" + cookieValue;
+    function createProcessTelemetryUnloadContext(telemetryChain, core, startAt) {
+        var config = createDynamicConfig(core.config);
+        var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
+        var context = internalContext.ctx;
+        function _processNext(unloadState) {
+            var nextPlugin = internalContext._next();
+            nextPlugin && nextPlugin.unload(context, unloadState);
+            return !nextPlugin;
+        }
+        function _createNew(plugins, startAt) {
+            if (plugins === void 0) { plugins = null; }
+            if (isArray(plugins)) {
+                plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt);
+            }
+            return createProcessTelemetryUnloadContext(plugins || context[_DYN_GET_NEXT ](), core, startAt);
         }
+        context[_DYN_PROCESS_NEXT ] = _processNext;
+        context[_DYN_CREATE_NEW ] = _createNew;
+        return context;
     }
-    function uaDisallowsSameSiteNone(userAgent) {
-        if (!isString(userAgent)) {
-            return false;
+    function createProcessTelemetryUpdateContext(telemetryChain, core, startAt) {
+        var config = createDynamicConfig(core.config);
+        var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
+        var context = internalContext.ctx;
+        function _processNext(updateState) {
+            return context.iterate(function (plugin) {
+                if (isFunction(plugin[_DYN_UPDATE ])) {
+                    plugin[_DYN_UPDATE ](context, updateState);
+                }
+            });
         }
-        if (strContains(userAgent, "CPU iPhone OS 12") || strContains(userAgent, "iPad; CPU OS 12")) {
-            return true;
+        function _createNew(plugins, startAt) {
+            if (plugins === void 0) { plugins = null; }
+            if (isArray(plugins)) {
+                plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt);
+            }
+            return createProcessTelemetryUpdateContext(plugins || context[_DYN_GET_NEXT ](), core, startAt);
         }
-        if (strContains(userAgent, "Macintosh; Intel Mac OS X 10_14") && strContains(userAgent, "Version/") && strContains(userAgent, "Safari")) {
-            return true;
+        context[_DYN_PROCESS_NEXT ] = _processNext;
+        context[_DYN_CREATE_NEW ] = _createNew;
+        return context;
+    }
+    function createTelemetryProxyChain(plugins, config, core, startAt) {
+        var firstProxy = null;
+        var add = startAt ? false : true;
+        if (isArray(plugins) && plugins[_DYN_LENGTH ] > 0) {
+            var lastProxy_1 = null;
+            arrForEach(plugins, function (thePlugin) {
+                if (!add && startAt === thePlugin) {
+                    add = true;
+                }
+                if (add && thePlugin && isFunction(thePlugin[STR_PROCESS_TELEMETRY ])) {
+                    var newProxy = createTelemetryPluginProxy(thePlugin, config, core);
+                    if (!firstProxy) {
+                        firstProxy = newProxy;
+                    }
+                    if (lastProxy_1) {
+                        lastProxy_1._setNext(newProxy);
+                    }
+                    lastProxy_1 = newProxy;
+                }
+            });
         }
-        if (strContains(userAgent, "Macintosh; Intel Mac OS X 10_14") && strEndsWith(userAgent, "AppleWebKit/605.1.15 (KHTML, like Gecko)")) {
-            return true;
+        if (startAt && !firstProxy) {
+            return createTelemetryProxyChain([startAt], config, core);
         }
-        if (strContains(userAgent, "Chrome/5") || strContains(userAgent, "Chrome/6")) {
-            return true;
+        return firstProxy;
+    }
+    function createTelemetryPluginProxy(plugin, config, core) {
+        var nextProxy = null;
+        var hasProcessTelemetry = isFunction(plugin[STR_PROCESS_TELEMETRY ]);
+        var hasSetNext = isFunction(plugin[_DYN_SET_NEXT_PLUGIN ]);
+        var chainId;
+        if (plugin) {
+            chainId = plugin[_DYN_IDENTIFIER ] + "-" + plugin[STR_PRIORITY ] + "-" + _chainId++;
         }
-        if (strContains(userAgent, "UnrealEngine") && !strContains(userAgent, "Chrome")) {
-            return true;
+        else {
+            chainId = "Unknown-0-" + _chainId++;
         }
-        if (strContains(userAgent, "UCBrowser/12") || strContains(userAgent, "UCBrowser/11")) {
-            return true;
+        var proxyChain = {
+            getPlugin: function () {
+                return plugin;
+            },
+            getNext: function () {
+                return nextProxy;
+            },
+            processTelemetry: _processTelemetry,
+            unload: _unloadPlugin,
+            update: _updatePlugin,
+            _id: chainId,
+            _setNext: function (nextPlugin) {
+                nextProxy = nextPlugin;
+            }
+        };
+        function _getTelCtx() {
+            var itemCtx;
+            if (plugin && isFunction(plugin[strGetTelCtx])) {
+                itemCtx = plugin[strGetTelCtx]();
+            }
+            if (!itemCtx) {
+                itemCtx = createProcessTelemetryContext(proxyChain, config, core);
+            }
+            return itemCtx;
         }
-        return false;
-    }
-
-    var defaultValues$1 = {
-        perfEvtsSendAll: false
-    };
-    function _runListeners(listeners, name, isAsync, callback) {
-        arrForEach(listeners, function (listener) {
-            if (listener && listener[name]) {
-                if (isAsync) {
-                    scheduleTimeout(function () { return callback(listener); }, 0);
-                }
-                else {
+        function _processChain(itemCtx, processPluginFn, name, details, isAsync) {
+            var hasRun = false;
+            var identifier = plugin ? plugin[_DYN_IDENTIFIER ] : strTelemetryPluginChain;
+            var hasRunContext = itemCtx[strHasRunFlags];
+            if (!hasRunContext) {
+                hasRunContext = itemCtx[strHasRunFlags] = {};
+            }
+            itemCtx.setNext(nextProxy);
+            if (plugin) {
+                doPerf(itemCtx[STR_CORE ](), function () { return identifier + ":" + name; }, function () {
+                    hasRunContext[chainId] = true;
                     try {
-                        callback(listener);
+                        var nextId = nextProxy ? nextProxy._id : STR_EMPTY;
+                        if (nextId) {
+                            hasRunContext[nextId] = false;
+                        }
+                        hasRun = processPluginFn(itemCtx);
                     }
-                    catch (e) {
+                    catch (error) {
+                        var hasNextRun = nextProxy ? hasRunContext[nextProxy._id] : true;
+                        if (hasNextRun) {
+                            hasRun = true;
+                        }
+                        if (!nextProxy || !hasNextRun) {
+                            _throwInternal(itemCtx[_DYN_DIAG_LOG ](), 1 , 73 , "Plugin [" + identifier + "] failed during " + name + " - " + dumpObj(error) + ", run flags: " + dumpObj(hasRunContext));
+                        }
                     }
+                }, details, isAsync);
+            }
+            return hasRun;
+        }
+        function _processTelemetry(env, itemCtx) {
+            itemCtx = itemCtx || _getTelCtx();
+            function _callProcessTelemetry(itemCtx) {
+                if (!plugin || !hasProcessTelemetry) {
+                    return false;
+                }
+                var pluginState = _getPluginState(plugin);
+                if (pluginState[_DYN_TEARDOWN ] || pluginState[STR_DISABLED]) {
+                    return false;
                 }
+                if (hasSetNext) {
+                    plugin[_DYN_SET_NEXT_PLUGIN ](nextProxy);
+                }
+                plugin[STR_PROCESS_TELEMETRY ](env, itemCtx);
+                return true;
             }
-        });
-    }
-    var NotificationManager = /** @class */ (function () {
-        function NotificationManager(config) {
-            this.listeners = [];
-            var perfEvtsSendAll;
-            var cfgHandler = createDynamicConfig(config, defaultValues$1);
-            cfgHandler[_DYN_WATCH ](function (details) {
-                perfEvtsSendAll = !!details.cfg.perfEvtsSendAll;
-            });
-            dynamicProto(NotificationManager, this, function (_self) {
-                _self[_DYN_ADD_NOTIFICATION_LIS1 ] = function (listener) {
-                    _self.listeners[_DYN_PUSH ](listener);
-                };
-                _self[_DYN_REMOVE_NOTIFICATION_2 ] = function (listener) {
-                    var index = arrIndexOf(_self[_DYN_LISTENERS ], listener);
-                    while (index > -1) {
-                        _self.listeners[_DYN_SPLICE ](index, 1);
-                        index = arrIndexOf(_self[_DYN_LISTENERS ], listener);
+            if (!_processChain(itemCtx, _callProcessTelemetry, "processTelemetry", function () { return ({ item: env }); }, !(env.sync))) {
+                itemCtx[_DYN_PROCESS_NEXT ](env);
+            }
+        }
+        function _unloadPlugin(unloadCtx, unloadState) {
+            function _callTeardown() {
+                var hasRun = false;
+                if (plugin) {
+                    var pluginState = _getPluginState(plugin);
+                    var pluginCore = plugin[STR_CORE] || pluginState[STR_CORE ];
+                    if (plugin && (!pluginCore || pluginCore === unloadCtx.core()) && !pluginState[_DYN_TEARDOWN ]) {
+                        pluginState[STR_CORE ] = null;
+                        pluginState[_DYN_TEARDOWN ] = true;
+                        pluginState[_DYN_IS_INITIALIZED ] = false;
+                        if (plugin[_DYN_TEARDOWN ] && plugin[_DYN_TEARDOWN ](unloadCtx, unloadState) === true) {
+                            hasRun = true;
+                        }
                     }
-                };
-                _self[STR_EVENTS_SENT ] = function (events) {
-                    _runListeners(_self[_DYN_LISTENERS ], STR_EVENTS_SENT, true, function (listener) {
-                        listener[STR_EVENTS_SENT ](events);
-                    });
-                };
-                _self[STR_EVENTS_DISCARDED ] = function (events, reason) {
-                    _runListeners(_self[_DYN_LISTENERS ], STR_EVENTS_DISCARDED, true, function (listener) {
-                        listener[STR_EVENTS_DISCARDED ](events, reason);
-                    });
-                };
-                _self[STR_EVENTS_SEND_REQUEST ] = function (sendReason, isAsync) {
-                    _runListeners(_self[_DYN_LISTENERS ], STR_EVENTS_SEND_REQUEST, isAsync, function (listener) {
-                        listener[STR_EVENTS_SEND_REQUEST ](sendReason, isAsync);
-                    });
-                };
-                _self[STR_PERF_EVENT ] = function (perfEvent) {
-                    if (perfEvent) {
-                        if (perfEvtsSendAll || !perfEvent[_DYN_IS_CHILD_EVT ]()) {
-                            _runListeners(_self[_DYN_LISTENERS ], STR_PERF_EVENT, false, function (listener) {
-                                if (perfEvent[_DYN_IS_ASYNC ]) {
-                                    scheduleTimeout(function () { return listener[STR_PERF_EVENT ](perfEvent); }, 0);
-                                }
-                                else {
-                                    listener[STR_PERF_EVENT ](perfEvent);
-                                }
-                            });
+                }
+                return hasRun;
+            }
+            if (!_processChain(unloadCtx, _callTeardown, "unload", function () { }, unloadState[_DYN_IS_ASYNC ])) {
+                unloadCtx[_DYN_PROCESS_NEXT ](unloadState);
+            }
+        }
+        function _updatePlugin(updateCtx, updateState) {
+            function _callUpdate() {
+                var hasRun = false;
+                if (plugin) {
+                    var pluginState = _getPluginState(plugin);
+                    var pluginCore = plugin[STR_CORE] || pluginState[STR_CORE ];
+                    if (plugin && (!pluginCore || pluginCore === updateCtx.core()) && !pluginState[_DYN_TEARDOWN ]) {
+                        if (plugin[_DYN_UPDATE ] && plugin[_DYN_UPDATE ](updateCtx, updateState) === true) {
+                            hasRun = true;
                         }
                     }
-                };
-            });
+                }
+                return hasRun;
+            }
+            if (!_processChain(updateCtx, _callUpdate, "update", function () { }, false)) {
+                updateCtx[_DYN_PROCESS_NEXT ](updateState);
+            }
         }
-        NotificationManager.__ieDyn=1;
-        return NotificationManager;
+        return objFreeze(proxyChain);
+    }
+    var ProcessTelemetryContext = /** @class */ (function () {
+        function ProcessTelemetryContext(pluginChain, config, core, startAt) {
+            var _self = this;
+            var context = createProcessTelemetryContext(pluginChain, config, core, startAt);
+            proxyFunctions(_self, context, objKeys(context));
+        }
+        return ProcessTelemetryContext;
     }());
 
     function createUnloadHandlerContainer() {
@@ -4002,6 +3808,7 @@
     function _validateExtensions(logger, channelPriority, allExtensions) {
         var _a;
         var coreExtensions = [];
+        var channels = [];
         var extPriorities = {};
         arrForEach(allExtensions, function (ext) {
             if (isNullOrUndefined(ext) || isNullOrUndefined(ext[_DYN_INITIALIZE ])) {
@@ -4020,11 +3827,13 @@
             if (!extPriority || extPriority < channelPriority) {
                 coreExtensions[_DYN_PUSH ](ext);
             }
+            else {
+                channels[_DYN_PUSH ](ext);
+            }
         });
-        return _a = {
-                all: allExtensions
-            },
+        return _a = {},
             _a[STR_CORE ] = coreExtensions,
+            _a[STR_CHANNELS ] = channels,
             _a;
     }
     function _isPluginPresent(thePlugin, plugins) {
@@ -4102,10 +3911,8 @@
             var _cookieManager;
             var _pluginChain;
             var _configExtensions;
-            var _coreExtensions;
-            var _channelControl;
             var _channelConfig;
-            var _channelQueue;
+            var _channels;
             var _isUnloading;
             var _telemetryInitializerPlugin;
             var _internalLogsEventName;
@@ -4152,20 +3959,26 @@
                     _configExtensions[_DYN_PUSH ].apply(_configExtensions, __spreadArrayFn(__spreadArrayFn([], extensions, false), cfgExtensions));
                     _channelConfig = config[STR_CHANNELS ];
                     _initPluginChain(null);
-                    if (!_channelQueue || _channelQueue[_DYN_LENGTH ] === 0) {
+                    if (!_channels || _channels[_DYN_LENGTH ] === 0) {
                         throwError("No " + STR_CHANNELS + " available");
                     }
+                    if (_channels[_DYN_LENGTH ] > 1) {
+                        var teeController = _self[_DYN_GET_PLUGIN ]("TeeChannelController");
+                        if (!teeController || !teeController.plugin) {
+                            _throwInternal(_self[_DYN_LOGGER ], 1 , 28 , "TeeChannel required");
+                        }
+                    }
                     _registerDelayedCfgListener(config, _cfgListeners, _self[_DYN_LOGGER ]);
                     _cfgListeners = null;
                     _isInitialized = true;
                     _self.releaseQueue();
                     _self[_DYN_POLL_INTERNAL_LOGS ]();
                 };
-                _self.getTransmissionControls = function () {
+                _self.getChannels = function () {
                     var controls = [];
-                    if (_channelQueue) {
-                        arrForEach(_channelQueue, function (channels) {
-                            controls[_DYN_PUSH ](channels.queue);
+                    if (_channels) {
+                        arrForEach(_channels, function (channel) {
+                            controls[_DYN_PUSH ](channel);
                         });
                     }
                     return objFreeze(controls);
@@ -4316,9 +4129,7 @@
                         _self[_DYN_STOP_POLLING_INTERNA3 ]();
                         processUnloadCtx[_DYN_PROCESS_NEXT ](unloadState);
                     }
-                    if (!_flushChannels(isAsync, _doUnload, 6 , cbTimeout)) {
-                        _doUnload(false);
-                    }
+                    if (!_flushChannels(isAsync, _doUnload, 6 , cbTimeout)) ;
                 };
                 _self[_DYN_GET_PLUGIN ] = _getPlugin;
                 _self.addPlugin = function (plugin, replaceExisting, isAsync, addCb) {
@@ -4399,7 +4210,7 @@
                 _self.evtNamespace = function () {
                     return _evtNamespace;
                 };
-                _self[_DYN_FLUSH ] = _flushChannels;
+                _self.flush = _flushChannels;
                 _self.getTraceCtx = function (createNew) {
                     if (!_traceCtx) {
                         _traceCtx = createDistributedTraceContext();
@@ -4496,11 +4307,9 @@
                     _cfgPerfManager = null;
                     _cookieManager = null;
                     _pluginChain = null;
-                    _coreExtensions = null;
                     _configExtensions = [];
-                    _channelControl = null;
                     _channelConfig = null;
-                    _channelQueue = null;
+                    _channels = null;
                     _isUnloading = false;
                     _internalLogsEventName = null;
                     _evtNamespace = createUniqueNamespace("AIBaseCore", true);
@@ -4517,32 +4326,19 @@
                 }
                 function _initPluginChain(updateState) {
                     var theExtensions = _validateExtensions(_self[_DYN_LOGGER ], ChannelControllerPriority, _configExtensions);
-                    _coreExtensions = theExtensions[STR_CORE ];
                     _pluginChain = null;
                     _pluginVersionString = null;
                     _pluginVersionStringArr = null;
-                    var allExtensions = theExtensions.all;
-                    _channelQueue = objFreeze(createChannelQueues(_channelConfig, allExtensions, _self));
-                    if (_channelControl) {
-                        var idx = arrIndexOf(allExtensions, _channelControl);
-                        if (idx !== -1) {
-                            allExtensions[_DYN_SPLICE ](idx, 1);
-                        }
-                        idx = arrIndexOf(_coreExtensions, _channelControl);
-                        if (idx !== -1) {
-                            _coreExtensions[_DYN_SPLICE ](idx, 1);
-                        }
-                        _channelControl._setQueue(_channelQueue);
-                    }
-                    else {
-                        _channelControl = createChannelControllerPlugin(_channelQueue, _self);
-                    }
-                    allExtensions[_DYN_PUSH ](_channelControl);
-                    _coreExtensions[_DYN_PUSH ](_channelControl);
-                    _extensions = sortPlugins(allExtensions);
-                    _channelControl[_DYN_INITIALIZE ](_configHandler.cfg, _self, allExtensions);
-                    initializePlugins(_createTelCtx(), allExtensions);
-                    _extensions = objFreeze(sortPlugins(_coreExtensions || [])).slice();
+                    _channels = (_channelConfig || [])[0] || [];
+                    _channels = sortPlugins(arrAppend(_channels, theExtensions[STR_CHANNELS ]));
+                    var allExtensions = sortPlugins(theExtensions[STR_CORE ]);
+                    arrAppend(allExtensions, _channels);
+                    _extensions = objFreeze(allExtensions);
+                    var rootCtx = _createTelCtx();
+                    if (_channels && _channels[_DYN_LENGTH ] > 0) {
+                        initializePlugins(rootCtx[_DYN_CREATE_NEW ](_channels), allExtensions);
+                    }
+                    initializePlugins(rootCtx, allExtensions);
                     if (updateState) {
                         _doUpdate(updateState);
                     }
@@ -4551,14 +4347,11 @@
                     var theExt = null;
                     var thePlugin = null;
                     arrForEach(_extensions, function (ext) {
-                        if (ext[_DYN_IDENTIFIER ] === pluginIdentifier && ext !== _channelControl && ext !== _telemetryInitializerPlugin) {
+                        if (ext[_DYN_IDENTIFIER ] === pluginIdentifier && ext !== _telemetryInitializerPlugin) {
                             thePlugin = ext;
                             return -1;
                         }
                     });
-                    if (!thePlugin && _channelControl) {
-                        thePlugin = _channelControl.getChannel(pluginIdentifier);
-                    }
                     if (thePlugin) {
                         theExt = {
                             plugin: thePlugin,
@@ -4594,7 +4387,7 @@
                 }
                 function _getPluginChain() {
                     if (!_pluginChain) {
-                        var extensions = (_coreExtensions || []).slice();
+                        var extensions = (_extensions || []).slice();
                         if (arrIndexOf(extensions, _telemetryInitializerPlugin) === -1) {
                             extensions[_DYN_PUSH ](_telemetryInitializerPlugin);
                         }
@@ -4662,10 +4455,46 @@
                     }
                 }
                 function _flushChannels(isAsync, callBack, sendReason, cbTimeout) {
-                    if (_channelControl) {
-                        return _channelControl[_DYN_FLUSH ](isAsync, callBack, sendReason || 6 , cbTimeout);
+                    var waiting = 1;
+                    var doneIterating = false;
+                    var cbTimer = null;
+                    cbTimeout = cbTimeout || 5000;
+                    function doCallback() {
+                        waiting--;
+                        if (doneIterating && waiting === 0) {
+                            cbTimer && cbTimer[_DYN_CANCEL ]();
+                            cbTimer = null;
+                            callBack && callBack(doneIterating);
+                            callBack = null;
+                        }
+                    }
+                    if (_channels && _channels[_DYN_LENGTH ] > 0) {
+                        var flushCtx = _createTelCtx()[_DYN_CREATE_NEW ](_channels);
+                        flushCtx.iterate(function (plugin) {
+                            if (plugin.flush) {
+                                waiting++;
+                                var handled_1 = false;
+                                if (!plugin.flush(isAsync, function () {
+                                    handled_1 = true;
+                                    doCallback();
+                                }, sendReason)) {
+                                    if (!handled_1) {
+                                        if (isAsync && cbTimer == null) {
+                                            cbTimer = scheduleTimeout(function () {
+                                                cbTimer = null;
+                                                doCallback();
+                                            }, cbTimeout);
+                                        }
+                                        else {
+                                            doCallback();
+                                        }
+                                    }
+                                }
+                            }
+                        });
                     }
-                    callBack && callBack(false);
+                    doneIterating = true;
+                    doCallback();
                     return true;
                 }
                 function _initDebugListener() {