@microsoft/applicationinsights-web-basic 3.0.0-beta.2211-01 → 3.0.0-beta.2211-04

package/browser/aib.2.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript Web SDK - Basic, 3.0.0-beta.2211-01
+ * Application Insights JavaScript Web SDK - Basic, 3.0.0-beta.2211-04
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -1080,6 +1080,22 @@
         return _scheduleTimeoutWith(this, setTimeout, clearTimeout, _extractArgs(arguments, 0));
     }
 
+    function scheduleInterval(callback, timeout) {
+        var self = this;
+        var theArguments = arguments;
+        var intervalId = setInterval.apply(self, theArguments);
+        return {
+            cancel: function () {
+                clearInterval(intervalId);
+            },
+            refresh: function () {
+                clearInterval(intervalId);
+                intervalId = setInterval.apply(self, theArguments);
+                return this;
+            }
+        };
+    }
+
     var createEnumStyle = createEnum;
     var createValueMap = createTypeMap;
 
@@ -1094,9 +1110,12 @@
     var _DYN_APPLY = "apply";
     var _DYN_PUSH$1 = "push";
     var _DYN_SPLICE = "splice";
-    var _DYN_INITIALIZE$1 = "initialize";
+    var _DYN_CANCEL = "cancel";
+    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$2 = "name";
     var _DYN_TIME = "time";
     var _DYN_PROCESS_NEXT = "processNext";
@@ -1107,10 +1126,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$1 = "message";
@@ -1120,8 +1138,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$1 = "split";
     var _DYN_NODE_TYPE = "nodeType";
@@ -1547,7 +1563,7 @@
     }
 
     var _objDefineProperty = ObjDefineProperty;
-    var version = "3.0.0-beta.2211-01";
+    var version = "3.0.0-beta.2211-04";
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _createAccessor(target, prop, value) {
@@ -1881,7 +1897,7 @@
             if (_waitingHandlers) {
                 var notifyHandlers = _waitingHandlers;
                 _waitingHandlers = null;
-                _watcherTimer && _watcherTimer.cancel();
+                _watcherTimer && _watcherTimer[_DYN_CANCEL ]();
                 _watcherTimer = null;
                 var watcherFailures_1 = [];
                 arrForEach(notifyHandlers, function (handler) {
@@ -2041,6 +2057,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;
@@ -2254,1138 +2272,944 @@
         _getLogger(logger)[STR_WARN_TO_CONSOLE ](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$2 ] = 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;
-                });
+    var _a$3, _b$1;
+    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$3 = {},
+        _a$3[STR_DOMAIN] = { fb: "cookieDomain", dfVal: isNotNullOrUndefined },
+        _a$3.path = { fb: "cookiePath", dfVal: isNotNullOrUndefined },
+        _a$3.enabled = UNDEFINED_VALUE$1,
+        _a$3));
+    var rootDefaultConfig = (_b$1 = {
+            cookieCfg: {},
+            cookieDomain: UNDEFINED_VALUE$1,
+            cookiePath: UNDEFINED_VALUE$1
+        },
+        _b$1[strDisableCookiesUsage] = UNDEFINED_VALUE$1,
+        _b$1);
+    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;
             }
-            _self[_DYN_GET_CTX ] = function (key) {
-                if (key) {
-                    if (key === PerfEvent[strParentContextKey] || key === PerfEvent[strChildrenContextKey]) {
-                        return _self[key];
-                    }
-                    return (_self[strExecutionContextKey] || {})[key];
+        }
+        return _isIgnoredCookie(cookieMgrCfg, name);
+    }
+    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];
                 }
-                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;
-                    }
+                if (!isUndefined(rootConfig[strDisableCookiesUsage])) {
+                    cookieEnabled = !rootConfig[strDisableCookiesUsage];
                 }
-            };
-            _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$2 ]; lp++) {
-                        var childEvt = childEvts[lp];
-                        if (childEvt) {
-                            childTime += childEvt[_DYN_TIME ];
-                        }
-                    }
+                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);
                 }
-                _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;
+                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));
                     }
-                };
-                _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$1 ](perfEvt);
+                    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);
                             }
                         }
-                        perfMgr[_DYN_SET_CTX ](doPerfActiveKey, perfEvt);
-                        return func(perfEvt);
+                        if (!_isIE) {
+                            setValue(values, "max-age", STR_EMPTY + maxAgeSec, null, isUndefined);
+                        }
                     }
-                }
-                catch (ex) {
-                    if (perfEvt && perfEvt[_DYN_SET_CTX ]) {
-                        perfEvt[_DYN_SET_CTX ]("exception", ex);
+                    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;
                 }
-                finally {
-                    if (perfEvt) {
-                        perfMgr.fire(perfEvt);
+                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";
                     }
-                    perfMgr[_DYN_SET_CTX ](doPerfActiveKey, currentActive);
+                    _delCookieFn(name, _formatCookieValue(STR_EMPTY, values));
+                    result = true;
                 }
+                return result;
             }
-        }
-        return func();
-    }
-    function getGblPerfMgr() {
-        return _defaultPerfManager;
+        };
+        cookieMgr[strConfigCookieMgr] = cookieMgr;
+        return cookieMgr;
     }
-
-    var INVALID_TRACE_ID = "00000000000000000000000000000000";
-    var INVALID_SPAN_ID = "0000000000000000";
-    function _isValid(value, len, invalidValue) {
-        if (value && value[_DYN_LENGTH$2 ] === len && value !== invalidValue) {
-            return !!value.match(/^[\da-f]*$/i);
+    function 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) });
+            }
         }
-        return false;
-    }
-    function isValidTraceId(value) {
-        return _isValid(value, 32, INVALID_TRACE_ID);
-    }
-    function isValidSpanId(value) {
-        return _isValid(value, 16, INVALID_SPAN_ID);
-    }
-
-    var pluginStateData = createElmNodeData("plugin");
-    function _getPluginState(plugin) {
-        return pluginStateData.get(plugin, "state", {}, true);
+        return _supportsCookies;
     }
-    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 ];
-                }
-                if (!isInitialized) {
-                    initPlugins[_DYN_PUSH$1 ](thePlugin);
+    function _extractParts(theValue) {
+        var values = {};
+        if (theValue && theValue[_DYN_LENGTH$2 ]) {
+            var parts = strTrim(theValue)[_DYN_SPLIT$1 ](";");
+            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));
+                    }
                 }
-                lastPlugin = thePlugin;
-                proxy = proxy[_DYN_GET_NEXT ]();
-            }
+            });
         }
-        arrForEach(initPlugins, function (thePlugin) {
-            var core = processContext[STR_CORE ]();
-            thePlugin[_DYN_INITIALIZE$1 ](processContext.getCfg(), core, extensions, processContext[_DYN_GET_NEXT ]());
-            pluginState = _getPluginState(thePlugin);
-            if (!thePlugin[STR_CORE] && !pluginState[STR_CORE]) {
-                pluginState[STR_CORE] = core;
-            }
-            pluginState[_DYN_IS_INITIALIZED ] = true;
-            delete pluginState[_DYN_TEARDOWN ];
-        });
+        return values;
     }
-    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 _formatDate(theDate, func) {
+        if (isFunction(theDate[func])) {
+            return theDate[func]();
+        }
+        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 createDistributedTraceContext(parentCtx) {
-        var trace = {};
-        return {
-            getName: function () {
-                return trace[_DYN_NAME$2 ];
-            },
-            setName: function (newValue) {
-                parentCtx && parentCtx.setName(newValue);
-                trace[_DYN_NAME$2 ] = newValue;
-            },
-            getTraceId: function () {
-                return trace[_DYN_TRACE_ID$1 ];
-            },
-            setTraceId: function (newValue) {
-                parentCtx && parentCtx.setTraceId(newValue);
-                if (isValidTraceId(newValue)) {
-                    trace[_DYN_TRACE_ID$1 ] = 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;
+    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 cookieValue;
     }
-
-    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 ]();
+    function _setCookieValue(name, cookieValue) {
+        if (_doc) {
+            _doc[strCookie] = name + "=" + cookieValue;
         }
-        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 ]);
+    function uaDisallowsSameSiteNone(userAgent) {
+        if (!isString(userAgent)) {
+            return false;
         }
-        if (startAt !== null) {
-            _nextProxy = startAt ? _getNextProxyStart(telemetryChain, core, startAt) : telemetryChain;
+        if (strContains(userAgent, "CPU iPhone OS 12") || strContains(userAgent, "iPad; CPU OS 12")) {
+            return true;
         }
-        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$1 ]({
-                    func: onComplete,
-                    self: !isUndefined(that) ? that : context.ctx,
-                    args: args
-                });
-            }
+        if (strContains(userAgent, "Macintosh; Intel Mac OS X 10_14") && strContains(userAgent, "Version/") && strContains(userAgent, "Safari")) {
+            return true;
         }
-        function _moveNext() {
-            var nextProxy = _nextProxy;
-            _nextProxy = nextProxy ? nextProxy[_DYN_GET_NEXT ]() : null;
-            if (!nextProxy) {
-                var onComplete = _onComplete;
-                if (onComplete && onComplete[_DYN_LENGTH$2 ] > 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 = [];
-                }
-            }
-            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 = {};
-                }
-                dynamicHandler.set(cfg, STR_EXTENSION_CONFIG, extCfg);
-                extCfg = cfg[STR_EXTENSION_CONFIG ];
-                if (extCfg) {
-                    idCfg = extCfg[identifier];
-                    if (!idCfg && createIfMissing) {
-                        idCfg = {};
-                    }
-                    dynamicHandler.set(extCfg, identifier, idCfg);
-                    idCfg = extCfg[identifier];
-                }
-            }
-            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);
-                });
-            }
-            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;
-        }
-        function _iterateChain(cb) {
-            var nextPlugin;
-            while (!!(nextPlugin = context._next())) {
-                var plugin = nextPlugin[_DYN_GET_PLUGIN ]();
-                if (plugin) {
-                    cb(plugin);
-                }
-            }
-        }
-        return context;
-    }
-    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;
+        if (strContains(userAgent, "Macintosh; Intel Mac OS X 10_14") && strEndsWith(userAgent, "AppleWebKit/605.1.15 (KHTML, like Gecko)")) {
+            return true;
         }
-        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);
+        if (strContains(userAgent, "Chrome/5") || strContains(userAgent, "Chrome/6")) {
+            return true;
         }
-        context[_DYN_PROCESS_NEXT ] = _processNext;
-        context[_DYN_CREATE_NEW ] = _createNew;
-        return context;
-    }
-    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;
+        if (strContains(userAgent, "UnrealEngine") && !strContains(userAgent, "Chrome")) {
+            return true;
         }
-        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);
+        if (strContains(userAgent, "UCBrowser/12") || strContains(userAgent, "UCBrowser/11")) {
+            return true;
         }
-        context[_DYN_PROCESS_NEXT ] = _processNext;
-        context[_DYN_CREATE_NEW ] = _createNew;
-        return context;
+        return false;
     }
-    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 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 {
+                    try {
+                        callback(listener);
+                    }
+                    catch (e) {
+                    }
                 }
-            });
-        }
-        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);
-        }
-        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$2 ] > 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;
+    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$1 ](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 (lastProxy_1) {
-                        lastProxy_1._setNext(newProxy);
+                };
+                _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);
+                                }
+                            });
+                        }
                     }
-                    lastProxy_1 = newProxy;
-                }
+                };
             });
         }
-        if (startAt && !firstProxy) {
-            return createTelemetryProxyChain([startAt], config, core);
-        }
-        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++;
-        }
-        else {
-            chainId = "Unknown-0-" + _chainId++;
-        }
-        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;
-        }
-        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] = {};
+        NotificationManager.__ieDyn=1;
+        return NotificationManager;
+    }());
+
+    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$2 ] = 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;
+                });
             }
-            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;
+            _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; };
                         }
-                        hasRun = processPluginFn(itemCtx);
+                        _self[key] = value;
                     }
-                    catch (error) {
-                        var hasNextRun = nextProxy ? hasRunContext[nextProxy._id] : true;
-                        if (hasNextRun) {
-                            hasRun = true;
+                    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$2 ]; lp++) {
+                        var childEvt = childEvts[lp];
+                        if (childEvt) {
+                            childTime += childEvt[_DYN_TIME ];
                         }
-                        if (!nextProxy || !hasNextRun) {
-                            _throwInternal(itemCtx[_DYN_DIAG_LOG$1 ](), 1 , 73 , "Plugin [" + identifier + "] failed during " + name + " - " + dumpObj(error) + ", run flags: " + dumpObj(hasRunContext));
+                    }
+                }
+                _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);
                         }
                     }
-                }, details, isAsync);
-            }
-            return hasRun;
+                };
+                _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 _processTelemetry(env, itemCtx) {
-            itemCtx = itemCtx || _getTelCtx();
-            function _callProcessTelemetry(itemCtx) {
-                if (!plugin || !hasProcessTelemetry) {
-                    return false;
+        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$1 ](perfEvt);
+                            }
+                        }
+                        perfMgr[_DYN_SET_CTX ](doPerfActiveKey, perfEvt);
+                        return func(perfEvt);
+                    }
                 }
-                var pluginState = _getPluginState(plugin);
-                if (pluginState[_DYN_TEARDOWN ] || pluginState[STR_DISABLED]) {
-                    return false;
+                catch (ex) {
+                    if (perfEvt && perfEvt[_DYN_SET_CTX ]) {
+                        perfEvt[_DYN_SET_CTX ]("exception", ex);
+                    }
                 }
-                if (hasSetNext) {
-                    plugin[_DYN_SET_NEXT_PLUGIN ](nextProxy);
+                finally {
+                    if (perfEvt) {
+                        perfMgr.fire(perfEvt);
+                    }
+                    perfMgr[_DYN_SET_CTX ](doPerfActiveKey, currentActive);
                 }
-                plugin[STR_PROCESS_TELEMETRY ](env, itemCtx);
-                return true;
-            }
-            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;
-                        }
-                    }
+        return func();
+    }
+    function getGblPerfMgr() {
+        return _defaultPerfManager;
+    }
+
+    var INVALID_TRACE_ID = "00000000000000000000000000000000";
+    var INVALID_SPAN_ID = "0000000000000000";
+    function _isValid(value, len, invalidValue) {
+        if (value && value[_DYN_LENGTH$2 ] === len && value !== invalidValue) {
+            return !!value.match(/^[\da-f]*$/i);
+        }
+        return false;
+    }
+    function isValidTraceId(value) {
+        return _isValid(value, 32, INVALID_TRACE_ID);
+    }
+    function isValidSpanId(value) {
+        return _isValid(value, 16, INVALID_SPAN_ID);
+    }
+
+    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 ];
                 }
-                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;
-                        }
-                    }
+                if (!isInitialized) {
+                    initPlugins[_DYN_PUSH$1 ](thePlugin);
                 }
-                return hasRun;
-            }
-            if (!_processChain(updateCtx, _callUpdate, "update", function () { }, false)) {
-                updateCtx[_DYN_PROCESS_NEXT ](updateState);
+                lastPlugin = thePlugin;
+                proxy = proxy[_DYN_GET_NEXT ]();
             }
         }
-        return objFreeze(proxyChain);
+        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 ];
+        });
     }
-
-    var ChannelControllerPriority = 500;
-    var ChannelValidationMessage = "Channel has invalid priority - ";
-    function _addChannelQueue(channelQueue, queue, core) {
-        if (queue && isArray(queue) && queue[_DYN_LENGTH$2 ] > 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 ]);
+    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;
                 }
-            });
-            channelQueue[_DYN_PUSH$1 ]({
-                queue: objFreeze(queue),
-                chain: createTelemetryProxyChain(queue, core[_DYN_CONFIG ], core)
-            });
-        }
-    }
-    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$2 ] + 1) : 1;
-            function _runChainOnComplete() {
-                waiting--;
-                if (waiting === 0) {
-                    onComplete && onComplete();
-                    onComplete = null;
+                else if (bHasProcess) {
+                    result = -1;
                 }
             }
-            if (waiting > 0) {
-                arrForEach(theChannels, function (channels) {
-                    if (channels && channels.queue[_DYN_LENGTH$2 ] > 0) {
-                        var channelChain = channels.chain;
-                        var chainCtx = itemCtx[_DYN_CREATE_NEW ](channelChain);
-                        chainCtx[_DYN_ON_COMPLETE ](_runChainOnComplete);
-                        processFn(chainCtx);
-                    }
-                    else {
-                        waiting--;
-                    }
-                });
-            }
-            _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$2 ] > 0) {
-                arrForEach(channelQueue, function (channels) {
-                    if (channels && channels.queue[_DYN_LENGTH$2 ] > 0) {
-                        arrForEach(channels.queue, function (ext) {
-                            if (ext[_DYN_IDENTIFIER ] === pluginIdentifier) {
-                                thePlugin = ext;
-                                return -1;
-                            }
-                        });
-                        if (thePlugin) {
-                            return -1;
-                        }
-                    }
-                });
+            else {
+                result = extA ? 1 : -1;
             }
-            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$2 ] > 0) {
-                        initializePlugins(createProcessTelemetryContext(channels.chain, config, core), extensions);
-                    }
-                });
+            return result;
+        });
+    }
+    function createDistributedTraceContext(parentCtx) {
+        var trace = {};
+        return {
+            getName: function () {
+                return trace[_DYN_NAME$2 ];
             },
-            isInitialized: function () {
-                return isInitialized;
+            setName: function (newValue) {
+                parentCtx && parentCtx.setName(newValue);
+                trace[_DYN_NAME$2 ] = 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$1 ];
             },
-            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$1 ] = 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.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;
+                }
+            },
+            getTraceFlags: function () {
+                return trace[_DYN_TRACE_FLAGS ];
             },
-            _setQueue: function (queue) {
-                channelQueue = queue;
+            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$1 ](plugin);
-                }
-            });
-            _addChannelQueue(channelQueue, extensionQueue_1, core);
-        }
-        return channelQueue;
     }
 
-    var _a$3, _b$1;
-    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$3 = {},
-        _a$3[STR_DOMAIN] = { fb: "cookieDomain", dfVal: isNotNullOrUndefined },
-        _a$3.path = { fb: "cookiePath", dfVal: isNotNullOrUndefined },
-        _a$3.enabled = UNDEFINED_VALUE$1,
-        _a$3));
-    var rootDefaultConfig = (_b$1 = {
-            cookieCfg: {},
-            cookieDomain: UNDEFINED_VALUE$1,
-            cookiePath: UNDEFINED_VALUE$1
-        },
-        _b$1[strDisableCookiesUsage] = UNDEFINED_VALUE$1,
-        _b$1);
-    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 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 ]);
+    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$1 ]({
+                    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$2 ] > 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$2 ]) {
-            var parts = strTrim(theValue)[_DYN_SPLIT$1 ](";");
-            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$2 ] > 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 ](), 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$1 ](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);
+    }
 
     function createUnloadHandlerContainer() {
         var handlers = [];
@@ -3426,7 +3250,7 @@
             var _hooks;
             _initDefaults();
             dynamicProto(BaseTelemetryPlugin, _self, function (_self) {
-                _self[_DYN_INITIALIZE$1 ] = function (config, core, extensions, pluginChain) {
+                _self[_DYN_INITIALIZE ] = function (config, core, extensions, pluginChain) {
                     _setDefaults(config, core, pluginChain);
                     _isinitialized = true;
                 };
@@ -3648,9 +3472,10 @@
     function _validateExtensions(logger, channelPriority, allExtensions) {
         var _a;
         var coreExtensions = [];
+        var channels = [];
         var extPriorities = {};
         arrForEach(allExtensions, function (ext) {
-            if (isNullOrUndefined(ext) || isNullOrUndefined(ext[_DYN_INITIALIZE$1 ])) {
+            if (isNullOrUndefined(ext) || isNullOrUndefined(ext[_DYN_INITIALIZE ])) {
                 throwError(strValidationError);
             }
             var extPriority = ext[STR_PRIORITY ];
@@ -3666,11 +3491,13 @@
             if (!extPriority || extPriority < channelPriority) {
                 coreExtensions[_DYN_PUSH$1 ](ext);
             }
+            else {
+                channels[_DYN_PUSH$1 ](ext);
+            }
         });
-        return _a = {
-                all: allExtensions
-            },
+        return _a = {},
             _a[STR_CORE ] = coreExtensions,
+            _a[STR_CHANNELS ] = channels,
             _a;
     }
     function _isPluginPresent(thePlugin, plugins) {
@@ -3748,10 +3575,8 @@
             var _cookieManager;
             var _pluginChain;
             var _configExtensions;
-            var _coreExtensions;
-            var _channelControl;
             var _channelConfig;
-            var _channelQueue;
+            var _channels;
             var _isUnloading;
             var _telemetryInitializerPlugin;
             var _internalLogsEventName;
@@ -3765,14 +3590,15 @@
             var _extensions;
             var _pluginVersionStringArr;
             var _pluginVersionString;
-            var _internalLogPoller = 0;
+            var _internalLogPoller;
+            var _internalLogPollerListening;
             dynamicProto(AppInsightsCore, this, function (_self) {
                 _initDefaults();
                 _self["_getDbgPlgTargets"] = function () {
                     return [_extensions];
                 };
                 _self[_DYN_IS_INITIALIZED ] = function () { return _isInitialized; };
-                _self[_DYN_INITIALIZE$1 ] = function (config, extensions, logger, notificationManager) {
+                _self[_DYN_INITIALIZE ] = function (config, extensions, logger, notificationManager) {
                     if (_isUnloading) {
                         throwError(strSdkUnloadingError);
                     }
@@ -3797,19 +3623,26 @@
                     _configExtensions[_DYN_PUSH$1 ].apply(_configExtensions, __spreadArrayFn(__spreadArrayFn([], extensions, false), cfgExtensions));
                     _channelConfig = config[STR_CHANNELS ];
                     _initPluginChain(null);
-                    if (!_channelQueue || _channelQueue[_DYN_LENGTH$2 ] === 0) {
+                    if (!_channels || _channels[_DYN_LENGTH$2 ] === 0) {
                         throwError("No " + STR_CHANNELS + " available");
                     }
+                    if (_channels[_DYN_LENGTH$2 ] > 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$1 ](channels.queue);
+                    if (_channels) {
+                        arrForEach(_channels, function (channel) {
+                            controls[_DYN_PUSH$1 ](channel);
                         });
                     }
                     return objFreeze(controls);
@@ -3892,26 +3725,33 @@
                         });
                     }
                 };
-                _self.pollInternalLogs = function (eventName) {
+                _self[_DYN_POLL_INTERNAL_LOGS ] = function (eventName) {
                     _internalLogsEventName = eventName || null;
-                    _addUnloadHook(_configHandler[_DYN_WATCH ](function (details) {
-                        var interval = details.cfg.diagnosticLogInterval;
+                    function _startLogPoller(config) {
+                        var interval = config.diagnosticLogInterval;
                         if (!interval || !(interval > 0)) {
                             interval = 10000;
                         }
-                        if (_internalLogPoller) {
-                            clearInterval(_internalLogPoller);
-                        }
-                        _internalLogPoller = setInterval(function () {
+                        _internalLogPoller && _internalLogPoller[_DYN_CANCEL ]();
+                        _internalLogPoller = scheduleInterval(function () {
                             _flushInternalLogs();
                         }, interval);
-                    }));
+                    }
+                    if (!_internalLogPollerListening) {
+                        _internalLogPollerListening = true;
+                        _addUnloadHook(_configHandler[_DYN_WATCH ](function (details) {
+                            _startLogPoller(details.cfg);
+                        }));
+                    }
+                    else {
+                        _startLogPoller(_configHandler.cfg);
+                    }
                     return _internalLogPoller;
                 };
                 _self[_DYN_STOP_POLLING_INTERNA3 ] = function () {
                     if (_internalLogPoller) {
-                        clearInterval(_internalLogPoller);
-                        _internalLogPoller = 0;
+                        _internalLogPoller[_DYN_CANCEL ]();
+                        _internalLogPoller = null;
                         _flushInternalLogs();
                     }
                 };
@@ -3953,9 +3793,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) {
@@ -4036,7 +3874,7 @@
                 _self.evtNamespace = function () {
                     return _evtNamespace;
                 };
-                _self[_DYN_FLUSH ] = _flushChannels;
+                _self.flush = _flushChannels;
                 _self.getTraceCtx = function (createNew) {
                     if (!_traceCtx) {
                         _traceCtx = createDistributedTraceContext();
@@ -4133,11 +3971,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);
@@ -4154,32 +3990,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$1 ](_channelControl);
-                    _coreExtensions[_DYN_PUSH$1 ](_channelControl);
-                    _extensions = sortPlugins(allExtensions);
-                    _channelControl[_DYN_INITIALIZE$1 ](_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$2 ] > 0) {
+                        initializePlugins(rootCtx[_DYN_CREATE_NEW ](_channels), allExtensions);
+                    }
+                    initializePlugins(rootCtx, allExtensions);
                     if (updateState) {
                         _doUpdate(updateState);
                     }
@@ -4188,14 +4011,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,
@@ -4231,7 +4051,7 @@
                 }
                 function _getPluginChain() {
                     if (!_pluginChain) {
-                        var extensions = (_coreExtensions || []).slice();
+                        var extensions = (_extensions || []).slice();
                         if (arrIndexOf(extensions, _telemetryInitializerPlugin) === -1) {
                             extensions[_DYN_PUSH$1 ](_telemetryInitializerPlugin);
                         }
@@ -4299,10 +4119,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$2 ] > 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() {
@@ -5825,7 +5681,7 @@
         }
     }
     var EnvelopeCreator = {
-        Version: "3.0.0-beta.2211-01"
+        Version: "3.0.0-beta.2211-04"
     };
     function DependencyEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
         EnvelopeCreatorInit(logger, telemetryItem);
@@ -7213,7 +7069,6 @@
         return Sender;
     }(BaseTelemetryPlugin));
 
-    var _DYN_INITIALIZE = "initialize";
     var _DYN_DIAGNOSTIC_LOG_INTER0 = "diagnosticLogInterval";
 
     var ApplicationInsights = /** @class */ (function () {
@@ -7230,7 +7085,7 @@
                     get: function () { return config; }
                 });
                 _initialize();
-                _self[_DYN_INITIALIZE ] = _initialize;
+                _self.initialize = _initialize;
                 _self.getSKUDefaults = function () {
                     _self.config[_DYN_DIAGNOSTIC_LOG_INTER0 ] =
                         _self.config[_DYN_DIAGNOSTIC_LOG_INTER0 ] && _self.config[_DYN_DIAGNOSTIC_LOG_INTER0 ] > 0 ? _self.config[_DYN_DIAGNOSTIC_LOG_INTER0 ] : 10000;
@@ -7248,12 +7103,7 @@
                     "addUnloadCb"
                 ]);
                 function _initialize() {
-                    var extensions = [];
-                    var appInsightsChannel = new Sender();
-                    extensions.push(appInsightsChannel);
-                    core[_DYN_INITIALIZE ](_self.config, extensions);
-                    appInsightsChannel[_DYN_INITIALIZE ](_self.config, core, extensions);
-                    core.pollInternalLogs();
+                    core.initialize(_self.config, [new Sender()]);
                 }
             });
         }